def main(model_name='parameter_sweep', exp_name='default', azimuth=12, snr=0.2, freq_bands=128, max_freq=20000, elevations=25, mean_subtracted_map=True, ear='ipsi', normalization_type='sum_1', clean=False):
""" TODO
"""
logger = logging.getLogger(__name__)
logger.info('Parameter Sweep Experiment.')
########################################################################
######################## Set parameters ################################
########################################################################
# participant_numbers = np.array([1, 2, 3, 8, 9, 10, 11,
# 12, 15, 17, 18, 19, 20, 21, 27, 28, 33, 40])
participant_numbers = np.array([1, 2, 3, 8, 9, 10, 11,
12, 15, 17, 18, 19, 20,
21, 27, 28, 33, 40, 44,
48, 50, 51, 58, 59, 60,
61, 65, 119, 124, 126,
127, 131, 133, 134, 135,
137, 147, 148, 152, 153,
154, 155, 156, 158, 162,
163, 165])
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
sigma_smoothing_vals = np.arange(1, 3.0, 0.1)
sigma_gauss_norm_vals = np.arange(1, 3.0, 0.1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([exp_name, normalization_type, mean_subtracted_map, time_window, int(
snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize, len(elevations), ear])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file')
[scores, sigma_smoothing_vals, sigma_gauss_norm_vals] = pickle.load(f)
else:
scores = np.zeros((sigma_smoothing_vals.shape[0], sigma_gauss_norm_vals.shape[0], 3))
for i_par, par in enumerate(participant_numbers):
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(
freq_bands, par, snr, normalize, azimuth, time_window, max_freq=max_freq, diff_noise=False)
# Take only given elevations
psd_all_c = psd_all_c[:, elevations, :]
psd_all_i = psd_all_i[:, elevations, :]
### Get different noise data ###
psd_all_c_diff_noise, psd_all_i_diff_noise = generateData.create_data(
freq_bands, par, snr, normalize, azimuth, time_window, max_freq=max_freq, diff_noise=True)
# Take only given elevations
psd_all_c_diff_noise = psd_all_c_diff_noise[:, elevations, :]
psd_all_i_diff_noise = psd_all_i_diff_noise[:, elevations, :]
for i_smooth, sigma_smooth in enumerate(sigma_smoothing_vals):
for i_gauss, sigma_gauss in enumerate(sigma_gauss_norm_vals):
# filter data and integrate it
psd_mono, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
psd_all_i, psd_all_c, ear, normalization_type, sigma_smooth, sigma_gauss)
# create map from defined processed data
if mean_subtracted_map:
learned_map = psd_binaural_mean.mean(0)
else:
learned_map = psd_binaural.mean(0)
# filter data and integrate it
psd_mono_diff_noise, psd_mono_mean_diff_noise, psd_binaural_diff_noise, psd_binaural_mean_diff_noise = hp.process_inputs(
psd_all_i_diff_noise, psd_all_c_diff_noise, ear, normalization_type, sigma_smooth, sigma_gauss)
# # localize the sounds and save the results
# x_mono[i_par, :, :, :], y_mono[i_par, :] = hp.localize_sound(psd_mono, learned_map)
#
# # localize the sounds and save the results
# x_mono_mean[i_par, :, :, :], y_mono_mean[i_par, :, :] = hp.localize_sound(psd_mono_mean, learned_map)
#
# # localize the sounds and save the results
# x_bin[i_par, :, :, :], y_bin[i_par, :, :] = hp.localize_sound(psd_binaural, learned_map)
# localize the sounds and save the results
x_test, y_test = hp.localize_sound(psd_binaural_diff_noise, learned_map)
x_test, y_test = hp_vis.scale_v(x_test, y_test, len(elevations))
scores[i_smooth, i_gauss, :] += hp.get_localization_coefficients_score(x_test, y_test)
# get the mean scores over participants
scores = scores / len(participant_numbers)
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([scores, sigma_smoothing_vals, sigma_gauss_norm_vals], f)
def main(save_figs=False,
save_type='svg',
model_name='localize_all_participant',
exp_name='all_participants_default',
azimuth=12,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1):
logger = logging.getLogger(__name__)
logger.info('Showing localization results for a single participant')
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[
localization_results_binaural, localization_results_monaural,
q_ele_all, r_ipsi_all
] = pickle.load(f)
fig = plt.figure(figsize=(20, 5))
# plt.suptitle('Single Participant')
# Monoaural Data (Ipsilateral), No Mean Subtracted
ax1 = fig.add_subplot(1, 4, 1)
ax2 = fig.add_subplot(1, 4, 2)
ax3 = fig.add_subplot(1, 4, 3)
ax4 = fig.add_subplot(1, 4, 4)
# get the right values
x_mono = localization_results_monaural[:, :, :, 0]
y_mono = localization_results_monaural[:, :, :, 1]
x_mono_mean = localization_results_monaural[:, :, :, 0]
y_mono_mean = localization_results_monaural[:, :, :, 2]
x_bin = localization_results_binaural[:, :, :, 0]
y_bin = localization_results_binaural[:, :, :, 1]
x_bin_mean = localization_results_binaural[:, :, :, 0]
y_bin_mean = localization_results_binaural[:, :, :, 2]
# plot regression line for each participant
for i_par in range(x_mono.shape[0]):
hp_vis.plot_localization_result(x_mono[i_par],
y_mono[i_par],
ax1,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
ax1.set_title('Monoaural')
hp_vis.set_axis(ax1, len(elevations))
ax1.set_ylabel('Estimated Elevation [deg]')
ax1.set_xlabel('True Elevation [deg]')
# Monoaural Data (Ipsilateral), Mean Subtracted
hp_vis.plot_localization_result(x_mono_mean[i_par],
y_mono_mean[i_par],
ax2,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
ax2.set_title('Mono - Prior')
hp_vis.set_axis(ax2, len(elevations))
ax2.set_xlabel('True Elevation [deg]')
# Binaural Data (Ipsilateral), No Mean Subtracted
hp_vis.plot_localization_result(x_bin[i_par],
y_bin[i_par],
ax3,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
ax3.set_title('Binaural')
hp_vis.set_axis(ax3, len(elevations))
ax3.set_xlabel('True Elevation [deg]')
# Binaural Data (Ipsilateral), Mean Subtracted
hp_vis.plot_localization_result(x_bin_mean[i_par],
y_bin_mean[i_par],
ax4,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
ax4.set_title('Bin - Prior')
hp_vis.set_axis(ax4, len(elevations))
ax4.set_xlabel('True Elevation [deg]')
# plot a common regression line
x_mono_ = np.reshape(
x_mono, (x_mono.shape[0] * x_mono.shape[1], x_mono.shape[2]))
y_mono_ = np.reshape(
y_mono, (y_mono.shape[0] * y_mono.shape[1], y_mono.shape[2]))
x_mono_mean_ = np.reshape(x_mono_mean,
(x_mono_mean.shape[0] * x_mono_mean.shape[1],
x_mono_mean.shape[2]))
y_mono_mean_ = np.reshape(y_mono_mean,
(y_mono_mean.shape[0] * y_mono_mean.shape[1],
y_mono_mean.shape[2]))
x_bin_ = np.reshape(x_bin,
(x_bin.shape[0] * x_bin.shape[1], x_bin.shape[2]))
y_bin_ = np.reshape(y_bin,
(y_bin.shape[0] * y_bin.shape[1], y_bin.shape[2]))
x_bin_mean_ = np.reshape(
x_bin_mean,
(x_bin_mean.shape[0] * x_bin_mean.shape[1], x_bin_mean.shape[2]))
y_bin_mean_ = np.reshape(
y_bin_mean,
(y_bin_mean.shape[0] * y_bin_mean.shape[1], y_bin_mean.shape[2]))
hp_vis.plot_localization_result(x_mono_,
y_mono_,
ax1,
SOUND_FILES,
scale_values=True,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
hp_vis.plot_localization_result(x_mono_mean_,
y_mono_mean_,
ax2,
SOUND_FILES,
scale_values=True,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
hp_vis.plot_localization_result(x_bin_,
y_bin_,
ax3,
SOUND_FILES,
scale_values=True,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
hp_vis.plot_localization_result(x_bin_mean_,
y_bin_mean_,
ax4,
SOUND_FILES,
scale_values=True,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
plt.tight_layout()
if save_figs:
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
plt.savefig(
(fig_save_path / (model_name + '_' + exp_name +
'_localization.' + save_type)).as_posix(),
dpi=300)
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(save_figs=False, save_type='svg', model_name='parameter_sweep', exp_name='default', azimuth=12, snr=0.2, freq_bands=128, max_freq=20000, elevations=25, mean_subtracted_map=True, ear='ipsi', normalization_type='sum_1', clean=False):
logger = logging.getLogger(__name__)
logger.info('Showing parameter sweep results')
########################################################################
######################## Set parameters ################################
########################################################################
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([exp_name, normalization_type, mean_subtracted_map, time_window, int(
snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize, len(elevations), ear])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[scores,sigma_smoothing_vals,sigma_gauss_norm_vals] = pickle.load(f)
fig = plt.figure(figsize=(20, 5))
axes = fig.subplots(1,3,sharex=True,sharey=True)
ax = axes[0]
p = ax.pcolormesh(sigma_smoothing_vals, sigma_gauss_norm_vals, np.squeeze(scores[:, :, 0]),linewidth=0,rasterized=True)
p.set_edgecolor('face')
ax.set_xlabel(r'Gauss Normalization $\sigma$')
ax.set_ylabel(r'Smoothing $\sigma$')
# ax.set_title('Gain')
cbar = plt.colorbar(p,ax=ax)
cbar.set_label('Gain', rotation=270)
cbar.ax.get_yaxis().labelpad = 15
ax = axes[1]
p = ax.pcolormesh(sigma_smoothing_vals, sigma_gauss_norm_vals, np.squeeze(scores[:, :, 1]),linewidth=0,rasterized=True)
p.set_edgecolor('face')
ax.set_xlabel(r'Gauss Normalization $\sigma$')
# ax.set_ylabel('Smoothing Sigma')
# ax.set_title('Bias')
cbar = plt.colorbar(p,ax=ax)
cbar.set_label('Bias', rotation=270)
cbar.ax.get_yaxis().labelpad = 15
ax = axes[2]
p = ax.pcolormesh(sigma_smoothing_vals, sigma_gauss_norm_vals, np.squeeze(scores[:, :, 2]),linewidth=0,rasterized=True)
p.set_edgecolor('face')
ax.set_xlabel(r'Gauss Normalization $\sigma$')
# ax.set_ylabel('Smoothing Sigma')
# ax.set_title('Score')
cbar = plt.colorbar(p,ax=ax)
cbar.set_label('Score', rotation=270)
cbar.ax.get_yaxis().labelpad = 15
plt.tight_layout()
if save_figs:
exp_name_str = hp.create_exp_name([exp_name, normalization_type, 0, 1, mean_subtracted_map, time_window, int(
snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize, len(elevations), ear])
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
logger.info('Saving figures to ' + fig_save_path.as_posix())
plt.savefig((fig_save_path / (model_name + '_' + exp_name + '_sweep.' + save_type)).as_posix(), dpi=300)
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(save_figs=False,
save_type='svg',
model_name='elevation_spectra_maps',
exp_name='unfiltered',
azimuth=12,
participant_numbers=None,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
clean=False):
logger = logging.getLogger(__name__)
logger.info('Plotting elevation spectra map for different sounds')
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
# if participant_numbers is not given we use all of them
if not participant_numbers:
participant_numbers = np.array([
1, 2, 3, 8, 9, 10, 11, 12, 15, 17, 18, 19, 20, 21, 27, 28, 33, 40,
44, 48, 50, 51, 58, 59, 60, 61, 65, 119, 124, 126, 127, 131, 133,
134, 135, 137, 147, 148, 152, 153, 154, 155, 156, 158, 162, 163,
165
])
exp_name_str = hp.create_exp_name([
exp_name, time_window,
int(snr * 100), freq_bands, max_freq,
len(participant_numbers), (azimuth - 12) * 10, normalize,
len(elevations)
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
else:
# participant_numbers are given. need to be cast to int array
participant_numbers = np.array(
[int(i) for i in participant_numbers.split(',')])
print(participant_numbers)
exp_name_str = hp.create_exp_name([
exp_name, time_window,
int(snr * 100), freq_bands, max_freq, participant_numbers,
(azimuth - 12) * 10, normalize,
len(elevations)
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
########################################################################
########################################################################
fig_size = (7, 5)
# fig_size = (20, 14)
formatter = hp_vis.ERBFormatter(20, max_freq, unit='', places=0)
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[ipsi_maps, contra_maps] = pickle.load(f)
ipsi_maps = ipsi_maps[:, :, elevations, :]
contra_maps = contra_maps[:, :, elevations, :]
for i_par, par in enumerate(participant_numbers):
for i_sound, sound in enumerate(SOUND_FILES):
sound = sound.name.split('.')[0]
# IPSI
fig = plt.figure(figsize=fig_size)
ax = fig.add_subplot(1, 1, 1)
ax.set_title(sound)
# ax.imshow(np.squeeze(ipsi_maps[i_par, i_sound]),interpolation = 'bilinear')
data = np.squeeze(ipsi_maps[i_par, i_sound])
# ax.pcolormesh(np.squeeze(ipsi_maps[i_par, i_sound]),shading='gouraud',linewidth=0,rasterized=True)
c = ax.pcolormesh(np.linspace(0, 1, data.shape[1]),
np.linspace(-45, 90, data.shape[0]),
data,
shading='gouraud',
linewidth=0,
rasterized=True)
plt.colorbar(c)
ax.xaxis.set_major_formatter(formatter)
ax.set_xlabel('Frequency [Hz]')
ax.set_ylabel('Elevations [deg]')
# ax.set_yticklabels(t[1:-1])
if save_figs:
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name / (
'participant_' + str(par))
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
path_final = (
fig_save_path /
(model_name + '_' + exp_name + '_raw_maps_ipsi_' +
str(sound) + '.' + save_type)).as_posix()
plt.savefig(path_final, dpi=300, transparent=True)
logger.info('Writing File :' + path_final)
plt.close()
else:
plt.show()
# CONTRA
fig = plt.figure(figsize=fig_size)
ax = fig.add_subplot(1, 1, 1)
ax.set_title(sound)
# ax.pcolormesh(np.squeeze(contra_maps[i_par, i_sound]), shading='gouraud', linewidth=0, rasterized=True)
data = np.squeeze(contra_maps[i_par, i_sound])
# ax.pcolormesh(np.squeeze(ipsi_maps[i_par, i_sound]),shading='gouraud',linewidth=0,rasterized=True)
c = ax.pcolormesh(np.linspace(0, 1, data.shape[1]),
np.linspace(-45, 90, data.shape[0]),
data,
shading='gouraud',
linewidth=0,
rasterized=True)
plt.colorbar(c)
ax.xaxis.set_major_formatter(formatter)
ax.set_xlabel('Frequency [Hz]')
ax.set_ylabel('Elevations [deg]')
# ax.set_yticklabels(t[1:-1])
if save_figs:
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name / (
'participant_' + str(par))
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
path_final = (
fig_save_path /
(model_name + '_' + exp_name + '_raw_maps_contra_' +
str(sound) + '.' + save_type)).as_posix()
plt.savefig(path_final, dpi=300, transparent=True)
logger.info('Writing File :' + path_final)
plt.close()
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(save_figs=False,
save_type='svg',
model_name='map_learning',
exp_name='localization_all_maps',
azimuth=12,
snr=0.2,
n_trials=100,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False):
logger = logging.getLogger(__name__)
logger.info(
'Showing map learning results for all participants over differently learned maps'
)
########################################################################
######################## Set parameters ################################
########################################################################
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize,
len(elevations), ear, n_trials
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file', )
[mono_res, mono_mean_res, bin_res, bin_mean_res,
trial_used_ss] = pickle.load(f)
# ALL participant
fig = plt.figure(figsize=(20, 10))
axes = fig.subplots(4, 3)
# walk over maps
for i_maps in range(4):
# walk over linear regression values (gain,bias,score)
for i in range(3):
ax = axes[i_maps, i]
trials = np.reshape(trial_used_ss[i_maps],
(trial_used_ss[i_maps].shape[0] *
trial_used_ss[i_maps].shape[1]))
x = trials
bins = 25
data = np.reshape(
mono_res[i_maps],
(mono_res[i_maps].shape[0] * mono_res[i_maps].shape[1],
mono_res[i_maps].shape[2]))
y = data[:, i]
# sns.regplot(x=x, y=y, x_bins=bins, x_estimator=np.mean, fit_reg=True, logx=True, ax=ax, x_ci='ci', truncate=True, label='Monoaural')
sns.regplot(x=x,
y=y,
x_bins=bins,
x_estimator=np.mean,
fit_reg=True,
logx=False,
order=7,
ax=ax,
x_ci='ci',
truncate=True,
label='Monoaural')
data = np.reshape(mono_mean_res[i_maps],
(mono_mean_res[i_maps].shape[0] *
mono_mean_res[i_maps].shape[1],
mono_mean_res[i_maps].shape[2]))
y = data[:, i]
# sns.regplot(x=x, y=y, x_bins=bins, x_estimator=np.mean, fit_reg=True, logx=True, ax=ax, x_ci='ci', truncate=True, label='Mono - Prior')
sns.regplot(x=x,
y=y,
x_bins=bins,
x_estimator=np.mean,
fit_reg=True,
logx=False,
order=7,
ax=ax,
x_ci='ci',
truncate=True,
label='Mono - Prior')
data = np.reshape(
bin_res[i_maps],
(bin_res[i_maps].shape[0] * bin_res[i_maps].shape[1],
bin_res[i_maps].shape[2]))
y = data[:, i]
# sns.regplot(x=x, y=y, x_bins=bins, x_estimator=np.mean, fit_reg=True, logx=True, ax=ax, x_ci='ci', truncate=True, label='Binaural')
sns.regplot(x=x,
y=y,
x_bins=bins,
x_estimator=np.mean,
fit_reg=True,
logx=False,
order=7,
ax=ax,
x_ci='ci',
truncate=True,
label='Binaural')
data = np.reshape(bin_mean_res[i_maps],
(bin_mean_res[i_maps].shape[0] *
bin_mean_res[i_maps].shape[1],
bin_mean_res[i_maps].shape[2]))
y = data[:, i]
# sns.regplot(x=x, y=y, x_bins=bins, x_estimator=np.mean, fit_reg=True, logx=True, ax=ax, x_ci='ci', truncate=True, label='Bin - Prior')
sns.regplot(x=x,
y=y,
x_bins=bins,
x_estimator=np.mean,
fit_reg=True,
logx=False,
order=7,
ax=ax,
x_ci='ci',
truncate=True,
label='Bin - Prior')
ax.set_xlim([0, 200])
if i == 2:
lgd = ax.legend(loc=(1.03, 0.04))
if i == 0 or i == 2:
ax.set_ylim([-0.1, 1.3])
if i == 1:
ax.set_ylim([-0.0, 12])
# ax.scatter(trials, data[:, i])
# do the labeling
if i == 0:
ax.set_ylabel('Gain')
if i == 1:
ax.set_ylabel('Bias')
if i == 2:
ax.set_ylabel('Score')
if i_maps == 3:
ax.set_xlabel('# of Presented Sounds')
if save_figs:
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing,
sigma_gauss_norm, mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, (azimuth - 12) * 10,
normalize,
len(elevations), ear
])
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
logger.info('Saving figures to ' + fig_save_path.as_posix())
plt.savefig(
(fig_save_path / (model_name + '_' + exp_name +
'_map_learning.' + save_type)).as_posix(),
dpi=300,
bbox_extra_artists=(lgd, ),
bbox_inches='tight')
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(save_figs=False, save_type='svg', model_name='hrtf_creation', exp_name='single_participant', azimuth=12, participant_number=9, snr=0.2, freq_bands=24, max_freq=20000, elevations=25, mean_subtracted_map=True, ear='ipsi', normalization_type='sum_1', sigma_smoothing=0, sigma_gauss_norm=1):
logger = logging.getLogger(__name__)
logger.info('Showing HRTFs')
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
### Set Parameters of Input Files ###
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
######################################
# create unique experiment name
exp_name_str = hp.create_exp_name([exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm, mean_subtracted_map, time_window, int(
snr * 100), freq_bands, max_freq, participant_number, (azimuth - 12) * 10, normalize, len(elevations), ear])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
# set formatter for this plot
formatter = hp_vis.ERBFormatter(20, max_freq, unit='', places=0)
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[hrtfs_i, hrtfs_c, freqs] = pickle.load(f)
fig = plt.figure(figsize=(20, 5))
plt.suptitle('Participant: ' + str(participant_number))
# make sure we plot the correct range of elevations
end_el = -45 + 5.625*(len(elevations)-1)
# Monoaural Data (Ipsilateral), No Mean Subtracted
ax = fig.add_subplot(1, 2, 1)
# a = ax.pcolormesh(np.squeeze(hrtfs_i[:,:-5]))
data = hrtfs_i[:, 5:]
print(data.shape)
a = ax.pcolormesh(np.linspace(0, 1, data.shape[1]), np.linspace(-45, end_el, data.shape[0]),
data, shading='gouraud', linewidth=0, rasterized=True)
ax.xaxis.set_major_formatter(formatter)
# d
cbar = plt.colorbar(a)
cbar.ax.get_yaxis().labelpad = 20
cbar.set_label('Decibels [dB]', rotation=270)
ax.set_title('Ipsilateral')
ax.set_xlabel('Frequency [Hz]')
ax.set_ylabel('Elevations [deg]')
ax = fig.add_subplot(1, 2, 2)
data = hrtfs_c[:, 5:]
a = ax.pcolormesh(np.linspace(0, 1, data.shape[1]), np.linspace(-45, end_el, data.shape[0]),
data, shading='gouraud', linewidth=0, rasterized=True)
ax.xaxis.set_major_formatter(formatter)
# ax.set_xticklabels(np.linspace(0,max_freq/1000,len(ax.get_xticks())))
ax.set_title('Contralateral')
ax.set_xlabel('Frequency [Hz]')
ax.set_ylabel('Elevations [deg]')
cbar = plt.colorbar(a)
cbar.ax.get_yaxis().labelpad = 20
cbar.set_label('Decibels [dB]', rotation=270)
if save_figs:
exp_name_str = hp.create_exp_name([exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm, mean_subtracted_map, time_window, int(
snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize, len(elevations), ear])
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
logger.info('Saving figures to ' + fig_save_path.as_posix())
plt.savefig((fig_save_path / (model_name + '_' + exp_name + '_'+str(participant_number)+ '_raw_hrtfs.' + save_type)).as_posix(), dpi=300, transparent=True)
plt.close()
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(model_name='snr_experiment',
exp_name='default',
azimuth=12,
freq_bands=128,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False):
""" This script takes the filtered data and tries to localize sounds with a learned map
for all participants.
"""
logger = logging.getLogger(__name__)
logger.info('Testing localization performance for different SNRs')
########################################################################
######################## Set parameters ################################
########################################################################
participant_numbers = np.array([
1, 2, 3, 8, 9, 10, 11, 12, 15, 17, 18, 19, 20, 21, 27, 28, 33, 40, 44,
48, 50, 51, 58, 59, 60, 61, 65, 119, 124, 126, 127, 131, 133, 134, 135,
137, 147, 148, 152, 153, 154, 155, 156, 158, 162, 163, 165
])
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
snrs = np.arange(0.0, 1.1, 0.1)
#snrs = snrs[::-1]
#participant_numbers = participant_numbers[::-1]
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window, freq_bands, max_freq,
(azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file')
[scores] = pickle.load(f)
else:
# scores per participant, per snr, for 4 different learned maps, (gain,bias,score)
scores = np.zeros((len(participant_numbers), len(snrs), 4, 3))
for i_par, par in enumerate(participant_numbers):
for i_snr, snr in enumerate(snrs):
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(
freq_bands,
par,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq,
diff_noise=False)
# Take only given elevations
psd_all_c = psd_all_c[:, elevations, :]
psd_all_i = psd_all_i[:, elevations, :]
# filter data and integrate it
psd_mono, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
psd_all_i, psd_all_c, ear, normalization_type,
sigma_smoothing, sigma_gauss_norm)
# create map from defined processed data
if mean_subtracted_map:
learned_map = psd_binaural_mean.mean(0)
else:
learned_map = psd_binaural.mean(0)
### Different noise data ####
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(
freq_bands,
par,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq,
diff_noise=True)
# Take only given elevations
psd_all_c = psd_all_c[:, elevations, :]
psd_all_i = psd_all_i[:, elevations, :]
# filter data and integrate it
psd_mono, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
psd_all_i, psd_all_c, ear, normalization_type,
sigma_smoothing, sigma_gauss_norm)
# localize the sounds and save the results
x_test, y_test = hp.localize_sound(psd_mono, learned_map)
x_test, y_test = hp_vis.scale_v(x_test, y_test,
len(elevations))
scores[i_par, i_snr,
0, :] = hp.get_localization_coefficients_score(
x_test, y_test)
# localize the sounds and save the results
x_test, y_test = hp.localize_sound(psd_mono_mean, learned_map)
x_test, y_test = hp_vis.scale_v(x_test, y_test,
len(elevations))
scores[i_par, i_snr,
1, :] = hp.get_localization_coefficients_score(
x_test, y_test)
# localize the sounds and save the results
x_test, y_test = hp.localize_sound(psd_binaural, learned_map)
x_test, y_test = hp_vis.scale_v(x_test, y_test,
len(elevations))
scores[i_par, i_snr,
2, :] = hp.get_localization_coefficients_score(
x_test, y_test)
# localize the sounds and save the results
x_test, y_test = hp.localize_sound(psd_binaural_mean,
learned_map)
x_test, y_test = hp_vis.scale_v(x_test, y_test,
len(elevations))
scores[i_par, i_snr,
3, :] = hp.get_localization_coefficients_score(
x_test, y_test)
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([scores], f)
def main(save_figs=False,
save_type='svg',
model_name='hrtf_comparison',
exp_name='single_participant',
azimuth=12,
participant_number=9,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1):
logger = logging.getLogger(__name__)
logger.info(
'Showing Correlation Coefficient Maps between HRTFs and differntly learned Maps'
)
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
######################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, participant_number,
(azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[
hrtfs_i, hrtfs_c, learned_map_mono, learned_map_mono_mean,
learned_map_bin, learned_map_bin_mean
] = pickle.load(f)
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot(2, 2, 1)
ax.set_title('Mono Map')
tmp = np.concatenate((hrtfs_c, hrtfs_i, learned_map_mono))
tmp = np.corrcoef(tmp)
plot_corrcoeff(tmp, ax)
ax = fig.add_subplot(2, 2, 2)
ax.set_title('Mono-Mean Map')
tmp = np.concatenate((hrtfs_c, hrtfs_i, learned_map_mono_mean))
tmp = np.corrcoef(tmp)
plot_corrcoeff(tmp, ax)
ax = fig.add_subplot(2, 2, 3)
ax.set_title('Bin Map')
tmp = np.concatenate((hrtfs_c, hrtfs_i, learned_map_bin))
tmp = np.corrcoef(tmp)
plot_corrcoeff(tmp, ax)
ax = fig.add_subplot(2, 2, 4)
# ax = fig.add_subplot(1, 1, 1)
ax.set_title('Bin-Mean Map')
tmp = np.concatenate((hrtfs_c, hrtfs_i, learned_map_bin_mean))
tmp = np.corrcoef(tmp)
plot_corrcoeff(tmp, ax)
if save_figs:
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, 0, 1, mean_subtracted_map,
time_window,
int(snr * 100), freq_bands, max_freq, (azimuth - 12) * 10,
normalize,
len(elevations), ear
])
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
logger.info('Saving figures to ' + fig_save_path.as_posix())
plt.savefig(
(fig_save_path / (model_name + '_' + exp_name +
'_hrtfs_xcorr.' + save_type)).as_posix(),
dpi=300)
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(model_name='elevation_spectra_maps', exp_name='unfiltered', azimuth=12, participant_numbers=None, snr=0.2, freq_bands=24, max_freq=20000, elevations=25, clean=False):
""" TODO
"""
logger = logging.getLogger(__name__)
logger.info('Creating maps for all participants and sounds')
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
# if participant_numbers is not given we use all of them
if not participant_numbers:
participant_numbers = np.array([1, 2, 3, 8, 9, 10, 11,
12, 15, 17, 18, 19, 20,
21, 27, 28, 33, 40, 44,
48, 50, 51, 58, 59, 60,
61, 65, 119, 124, 126,
127, 131, 133, 134, 135,
137, 147, 148, 152, 153,
154, 155, 156, 158, 162,
163, 165])
exp_name_str = hp.create_exp_name([exp_name, time_window, int(snr * 100), freq_bands, max_freq,
len(participant_numbers), (azimuth - 12) * 10, normalize, len(elevations)])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
else:
# participant_numbers are given. need to be cast to int array
participant_numbers = np.array([int(i) for i in participant_numbers.split(',')])
print(participant_numbers)
exp_name_str = hp.create_exp_name([exp_name, time_window, int(snr * 100), freq_bands, max_freq,
participant_numbers, (azimuth - 12) * 10, normalize, len(elevations)])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
########################################################################
########################################################################
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file')
[ipsi_maps,contra_maps] = pickle.load(f)
else:
ipsi_maps = np.zeros((len(participant_numbers), len(SOUND_FILES), len(elevations), freq_bands))
contra_maps = np.zeros((len(participant_numbers), len(SOUND_FILES), len(elevations), freq_bands))
for i_par, par in enumerate(participant_numbers):
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(
freq_bands, par, snr, normalize, azimuth, time_window,max_freq=max_freq)
# Take only given elevations
psd_all_c = psd_all_c[:, elevations, :]
psd_all_i = psd_all_i[:, elevations, :]
ipsi_maps[i_par, :, :, :] = psd_all_i
contra_maps[i_par, :, :, :] = psd_all_c
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([ipsi_maps,contra_maps], f)
def main(save_figs=False,
save_type='svg',
model_name='different_learned_maps',
exp_name='localization_default',
azimuth=12,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False):
logger = logging.getLogger(__name__)
logger.info(
'Showing localization results for all participants over different learned maps'
)
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[
x_mono, y_mono, x_mono_mean, y_mono_mean, x_bin, y_bin,
x_bin_mean, y_bin_mean
] = pickle.load(f)
# define which elevations should be used
x_mono_all = x_mono[:, :, :, elevations, :]
y_mono_all = y_mono[:, :, :, elevations]
x_mono_mean_all = x_mono_mean[:, :, :, elevations, :]
y_mono_mean_all = y_mono_mean[:, :, :, elevations]
x_bin_all = x_bin[:, :, :, elevations, :]
y_bin_all = y_bin[:, :, :, elevations]
x_bin_mean_all = x_bin_mean[:, :, :, elevations, :]
y_bin_mean_all = y_bin_mean[:, :, :, elevations]
fig = plt.figure(figsize=(20, 20))
axes = fig.subplots(4, 4, sharex=True, sharey=True)
# plt.suptitle('Single Participant')
# plot regression line for each participant
for i_map in range(4):
# get right axis
ax1 = axes[i_map, 0]
ax2 = axes[i_map, 1]
ax3 = axes[i_map, 2]
ax4 = axes[i_map, 3]
# get the data for each map
x_mono = x_mono_all[i_map]
y_mono = y_mono_all[i_map]
x_mono_mean = x_mono_mean_all[i_map]
y_mono_mean = y_mono_mean_all[i_map]
x_bin = x_bin_all[i_map]
y_bin = y_bin_all[i_map]
x_bin_mean = x_bin_mean_all[i_map]
y_bin_mean = y_bin_mean_all[i_map]
for i_par in range(x_mono_all.shape[1]):
hp_vis.plot_localization_result(x_mono[i_par],
y_mono[i_par],
ax1,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
if i_map == 0:
ax1.set_title('Monoaural')
hp_vis.set_axis(ax1, len(elevations))
ax1.set_ylabel('Estimated Elevation \n [deg]')
if i_map == 3:
ax1.set_xlabel('True Elevation [deg]')
# Monoaural Data (Ipsilateral), Mean Subtracted
hp_vis.plot_localization_result(x_mono_mean[i_par],
y_mono_mean[i_par],
ax2,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
if i_map == 0:
ax2.set_title('Mono - Prior')
hp_vis.set_axis(ax2, len(elevations))
if i_map == 3:
ax2.set_xlabel('True Elevation [deg]')
# Binaural Data (Ipsilateral), No Mean Subtracted
hp_vis.plot_localization_result(x_bin[i_par],
y_bin[i_par],
ax3,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
if i_map == 0:
ax3.set_title('Binaural')
hp_vis.set_axis(ax3, len(elevations))
if i_map == 3:
ax3.set_xlabel('True Elevation [deg]')
# Binaural Data (Ipsilateral), Mean Subtracted
hp_vis.plot_localization_result(x_bin_mean[i_par],
y_bin_mean[i_par],
ax4,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
if i_map == 0:
ax4.set_title('Bin - Prior')
hp_vis.set_axis(ax4, len(elevations))
if i_map == 3:
ax4.set_xlabel('True Elevation [deg]')
# plot a common regression line
x_mono_ = np.reshape(x_mono, (x_mono.shape[0] * x_mono.shape[1],
x_mono.shape[2], x_mono.shape[3]))
y_mono_ = np.reshape(
y_mono, (y_mono.shape[0] * y_mono.shape[1], y_mono.shape[2]))
x_mono_mean_ = np.reshape(
x_mono_mean, (x_mono_mean.shape[0] * x_mono_mean.shape[1],
x_mono_mean.shape[2], x_mono_mean.shape[3]))
y_mono_mean_ = np.reshape(
y_mono_mean, (y_mono_mean.shape[0] * y_mono_mean.shape[1],
y_mono_mean.shape[2]))
x_bin_ = np.reshape(x_bin, (x_bin.shape[0] * x_bin.shape[1],
x_bin.shape[2], x_bin.shape[3]))
y_bin_ = np.reshape(
y_bin, (y_bin.shape[0] * y_bin.shape[1], y_bin.shape[2]))
x_bin_mean_ = np.reshape(
x_bin_mean, (x_bin_mean.shape[0] * x_bin_mean.shape[1],
x_bin_mean.shape[2], x_bin_mean.shape[3]))
y_bin_mean_ = np.reshape(
y_bin_mean, (y_bin_mean.shape[0] * y_bin_mean.shape[1],
y_bin_mean.shape[2]))
hp_vis.plot_localization_result(x_mono_,
y_mono_,
ax1,
SOUND_FILES,
scale_values=False,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
hp_vis.plot_localization_result(x_mono_mean_,
y_mono_mean_,
ax2,
SOUND_FILES,
scale_values=False,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
hp_vis.plot_localization_result(x_bin_,
y_bin_,
ax3,
SOUND_FILES,
scale_values=False,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
hp_vis.plot_localization_result(x_bin_mean_,
y_bin_mean_,
ax4,
SOUND_FILES,
scale_values=False,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
if save_figs:
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
logger.info('Saving figures to ' + fig_save_path.as_posix())
plt.savefig(
(fig_save_path / (model_name + '_' + exp_name +
'_localization.' + save_type)).as_posix(),
dpi=300)
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(model_name='single_participant',
exp_name='single_participant_default',
azimuth=12,
participant_number=9,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False):
""" This script takes the filtered data and tries to localize sounds with a learned map
for a single participant.
"""
logger = logging.getLogger(__name__)
logger.info('Localizing sounds for a single participant')
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, participant_number,
(azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file')
[
x_mono, y_mono, x_mono_mean, y_mono_mean, x_bin, y_bin,
x_bin_mean, y_bin_mean
] = pickle.load(f)
else:
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(freq_bands,
participant_number,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq,
diff_noise=False)
# Take only given elevations
psd_all_c = psd_all_c[:, elevations, :]
psd_all_i = psd_all_i[:, elevations, :]
# filter data and integrate it
psd_mono, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
psd_all_i, psd_all_c, ear, normalization_type, sigma_smoothing,
sigma_gauss_norm)
# create map from defined processed data
if mean_subtracted_map:
learned_map = psd_binaural_mean.mean(0)
else:
learned_map = psd_binaural.mean(0)
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(freq_bands,
participant_number,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq,
diff_noise=True)
# Take only given elevations
psd_all_c = psd_all_c[:, elevations, :]
psd_all_i = psd_all_i[:, elevations, :]
# filter data and integrate it
psd_mono, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
psd_all_i, psd_all_c, ear, normalization_type, sigma_smoothing,
sigma_gauss_norm)
# localize the sounds and save the results
x_mono, y_mono = hp.localize_sound(psd_mono, learned_map)
# localize the sounds and save the results
x_mono_mean, y_mono_mean = hp.localize_sound(psd_mono_mean,
learned_map)
# localize the sounds and save the results
x_bin, y_bin = hp.localize_sound(psd_binaural, learned_map)
# localize the sounds and save the results
x_bin_mean, y_bin_mean = hp.localize_sound(psd_binaural_mean,
learned_map)
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([
x_mono, y_mono, x_mono_mean, y_mono_mean, x_bin, y_bin,
x_bin_mean, y_bin_mean
], f)
def main(model_name='hrtf_creation',
exp_name='single_participant',
azimuth=12,
participant_number=9,
snr=0.0,
freq_bands=128,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False):
""" This script calculates the correlation coefficient between the ipsi- and contralateral HRTF and the learned maps for a single participant.
"""
logger = logging.getLogger(__name__)
logger.info('Just get the HRTFs of the given participant')
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
### IMPORTANT ###
# Use 128 freq_bands for better displaying
freq_bands = 128
logger.info('############## IMPORTANT ###############')
logger.info(
'############## Using 128 frequency by default! ###############')
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, participant_number,
(azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file')
[hrtfs_i, hrtfs_c, freqs] = pickle.load(f)
else:
hrtfs_c, hrtfs_i, freqs = generateHRTFs.create_data(freq_bands,
participant_number,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq,
clean=clean)
# # remove mean for later comparison
hrtfs_c = np.squeeze(hrtfs_c[0, elevations, :])
# hrtfs_c -= hrtfs_c.mean()
hrtfs_i = np.squeeze(hrtfs_i[0, elevations, :])
# hrtfs_i -= hrtfs_i.mean()
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([hrtfs_i, hrtfs_c, freqs], f)
def main(save_figs=False,
save_type='svg',
model_name='all_participants',
exp_name='localization_default',
azimuth=12,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False):
logger = logging.getLogger(__name__)
logger.info('Showing localization results for all participants')
########################################################################
######################## Set parameters ################################
########################################################################
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
participant_numbers = np.array([
1, 2, 3, 8, 9, 10, 11, 12, 15, 17, 18, 19, 20, 21, 27, 28, 33, 40, 44,
48, 50, 51, 58, 59, 60, 61, 65, 119, 124, 126, 127, 131, 133, 134, 135,
137, 147, 148, 152, 153, 154, 155, 156, 158, 162, 163, 165
])
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[
x_mono, y_mono, x_mono_mean, y_mono_mean, x_bin, y_bin,
x_bin_mean, y_bin_mean
] = pickle.load(f)
# define which elevations should be used
x_mono = x_mono[:, :, elevations, :]
y_mono = y_mono[:, :, elevations]
x_mono_mean = x_mono_mean[:, :, elevations, :]
y_mono_mean = y_mono_mean[:, :, elevations]
x_bin = x_bin[:, :, elevations, :]
y_bin = y_bin[:, :, elevations]
x_bin_mean = x_bin_mean[:, :, elevations, :]
y_bin_mean = y_bin_mean[:, :, elevations]
# save regression values for later usage
coeff_ms = np.zeros((4, participant_numbers.shape[0]))
coeff_bs = np.zeros((4, participant_numbers.shape[0]))
scores = np.zeros((4, participant_numbers.shape[0]))
# plot regression line for each participant
for i_par, par in enumerate(participant_numbers):
coeff_ms[0, i_par], coeff_bs[0, i_par], scores[
0, i_par] = get_regression_values(x_mono[i_par], y_mono[i_par])
coeff_ms[1, i_par], coeff_bs[1, i_par], scores[
1, i_par] = get_regression_values(x_mono_mean[i_par],
y_mono_mean[i_par])
coeff_ms[2, i_par], coeff_bs[2, i_par], scores[
2, i_par] = get_regression_values(x_bin[i_par], y_bin[i_par])
coeff_ms[3, i_par], coeff_bs[3, i_par], scores[
3, i_par] = get_regression_values(x_bin_mean[i_par],
y_bin_mean[i_par])
# sns.set_palette('muted')
# my_pal = sns.color_palette("hls", 8)
fig = plt.figure(figsize=(20, 5))
my_pal = [(31 / 255, 119 / 255, 180 / 255),
(0.3333333333333333, 0.6588235294117647,
0.40784313725490196),
(0.7686274509803922, 0.3058823529411765, 0.3215686274509804),
(0.5058823529411764, 0.4470588235294118, 0.6980392156862745)]
ax = fig.add_subplot(1, 3, 1)
ax.set_ylabel('Gain')
sns.boxplot(data=coeff_ms.T,
showfliers=True,
palette=hp_vis.MY_COLORS,
ax=ax,
linewidth=3)
ax.set_xticklabels(['Mono', 'Mono\n-Prior', 'Bin', 'Bin\n-Prior'])
ax = fig.add_subplot(1, 3, 2)
ax.set_ylabel('Bias')
sns.boxplot(data=coeff_bs.T,
showfliers=True,
palette=hp_vis.MY_COLORS,
ax=ax,
linewidth=3)
ax.set_xticklabels(['Mono', 'Mono\n-Prior', 'Bin', 'Bin\n-Prior'])
ax = fig.add_subplot(1, 3, 3)
ax.set_ylabel('Score')
sns.boxplot(data=scores.T,
showfliers=True,
palette=hp_vis.MY_COLORS,
ax=ax,
linewidth=3)
ax.set_xticklabels(['Mono', 'Mono\n-Prior', 'Bin', 'Bin\n-Prior'])
if save_figs:
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
logger.info('Saving figures to ' + fig_save_path.as_posix())
plt.savefig((fig_save_path /
(model_name + '_' + exp_name + '_regression_values.' +
save_type)).as_posix(),
dpi=300)
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(save_figs=False,
save_type='svg',
model_name='all_participants',
exp_name='localization_default',
azimuth=12,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False):
""" This script plots the localization quality for all participants over sounds
"""
logger = logging.getLogger(__name__)
logger.info('Showing localization results for all sounds')
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
########################################################################
######################## Set parameters ################################
########################################################################
participant_numbers = np.array([
1, 2, 3, 8, 9, 10, 11, 12, 15, 17, 18, 19, 20, 21, 27, 28, 33, 40, 44,
48, 50, 51, 58, 59, 60, 61, 65, 119, 124, 126, 127, 131, 133, 134, 135,
137, 147, 148, 152, 153, 154, 155, 156, 158, 162, 163, 165
])
sounds = np.array(
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[
x_mono, y_mono, x_mono_mean, y_mono_mean, x_bin, y_bin,
x_bin_mean, y_bin_mean
] = pickle.load(f)
# define which elevations should be used
x_mono = x_mono[:, :, elevations, :]
y_mono = y_mono[:, :, elevations]
x_mono_mean = x_mono_mean[:, :, elevations, :]
y_mono_mean = y_mono_mean[:, :, elevations]
x_bin = x_bin[:, :, elevations, :]
y_bin = y_bin[:, :, elevations]
x_bin_mean = x_bin_mean[:, :, elevations, :]
y_bin_mean = y_bin_mean[:, :, elevations]
fig = plt.figure(figsize=(20, 5))
# plt.suptitle('Single Participant')
# Monoaural Data (Ipsilateral), No Mean Subtracted
ax1 = fig.add_subplot(1, 4, 1)
ax2 = fig.add_subplot(1, 4, 2)
ax3 = fig.add_subplot(1, 4, 3)
ax4 = fig.add_subplot(1, 4, 4)
# plot regression line for each sound
for i_sound, sound in enumerate(sounds):
hp_vis.plot_localization_result(x_mono[:, i_sound],
y_mono[:, i_sound],
ax1,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
ax1.set_title('Monoaural')
hp_vis.set_axis(ax1, len(elevations))
ax1.set_ylabel('Estimated Elevation [deg]')
ax1.set_xlabel('True Elevation [deg]')
# Monoaural Data (Ipsilateral), Mean Subtracted
hp_vis.plot_localization_result(x_mono_mean[:, i_sound],
y_mono_mean[:, i_sound],
ax2,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
ax2.set_title('Mono - Prior')
hp_vis.set_axis(ax2, len(elevations))
ax2.set_xlabel('True Elevation [deg]')
# Binaural Data (Ipsilateral), No Mean Subtracted
hp_vis.plot_localization_result(x_bin[:, i_sound],
y_bin[:, i_sound],
ax3,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
ax3.set_title('Binaural')
hp_vis.set_axis(ax3, len(elevations))
ax3.set_xlabel('True Elevation [deg]')
# Binaural Data (Ipsilateral), Mean Subtracted
hp_vis.plot_localization_result(x_bin_mean[:, i_sound],
y_bin_mean[:, i_sound],
ax4,
SOUND_FILES,
scale_values=True,
linear_reg=True,
scatter_data=False)
ax4.set_title('Bin - Prior')
hp_vis.set_axis(ax4, len(elevations))
ax4.set_xlabel('True Elevation [deg]')
# plot a common regression line
x_mono_ = np.reshape(x_mono, (x_mono.shape[0] * x_mono.shape[1],
x_mono.shape[2], x_mono.shape[3]))
y_mono_ = np.reshape(
y_mono, (y_mono.shape[0] * y_mono.shape[1], y_mono.shape[2]))
x_mono_mean_ = np.reshape(x_mono_mean,
(x_mono_mean.shape[0] * x_mono_mean.shape[1],
x_mono_mean.shape[2], x_mono_mean.shape[3]))
y_mono_mean_ = np.reshape(y_mono_mean,
(y_mono_mean.shape[0] * y_mono_mean.shape[1],
y_mono_mean.shape[2]))
x_bin_ = np.reshape(
x_bin,
(x_bin.shape[0] * x_bin.shape[1], x_bin.shape[2], x_bin.shape[3]))
y_bin_ = np.reshape(y_bin,
(y_bin.shape[0] * y_bin.shape[1], y_bin.shape[2]))
x_bin_mean_ = np.reshape(x_bin_mean,
(x_bin_mean.shape[0] * x_bin_mean.shape[1],
x_bin_mean.shape[2], x_bin_mean.shape[3]))
y_bin_mean_ = np.reshape(
y_bin_mean,
(y_bin_mean.shape[0] * y_bin_mean.shape[1], y_bin_mean.shape[2]))
hp_vis.plot_localization_result(x_mono_,
y_mono_,
ax1,
SOUND_FILES,
scale_values=False,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
hp_vis.plot_localization_result(x_mono_mean_,
y_mono_mean_,
ax2,
SOUND_FILES,
scale_values=False,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
hp_vis.plot_localization_result(x_bin_,
y_bin_,
ax3,
SOUND_FILES,
scale_values=False,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
hp_vis.plot_localization_result(x_bin_mean_,
y_bin_mean_,
ax4,
SOUND_FILES,
scale_values=False,
linear_reg=True,
disp_values=True,
scatter_data=False,
reg_color="black")
# get the name of the sounds
sound_names = np.array([i.name.split('.')[0] for i in SOUND_FILES])
lgd = ax4.legend(sound_names, loc=(1.04, 0))
# plt.tight_layout()
if save_figs:
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
logger.info('Saving figures to ' + fig_save_path.as_posix())
plt.savefig((fig_save_path /
(model_name + '_' + exp_name +
'_localization_sounds.' + save_type)).as_posix(),
dpi=300,
bbox_extra_artists=(lgd, ),
bbox_inches='tight')
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(model_name='single_participant',
exp_name='single_participant_different_azis'):
""" Localizes sounds at azimuth 'azimuth' with a learned map at azimuth 0.
"""
logger = logging.getLogger(__name__)
logger.info(
'Localizing sounds for a single participant at different azimuths')
########################################################################
######################## Set parameters ################################
########################################################################
azimuth = 12
snr = 0.2
freq_bands = 128
max_freq = 20000
participant_number = 9
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, 25, 1)
# filtering parameters
normalization_type = 'sum_1'
sigma_smoothing = 0
sigma_gauss_norm = 1
# use the mean subtracted map as the learned map
mean_subtracted_map = True
# choose which ear to use 'contra' or 'ipsi'
ear = 'ipsi'
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, participant_number,
(azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file')
[
x_mono, y_mono, x_mono_mean, y_mono_mean, x_bin, y_bin,
x_bin_mean, y_bin_mean
] = pickle.load(f)
else:
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(freq_bands,
participant_number,
snr,
normalize,
12,
time_window,
max_freq=max_freq)
# Take only given elevations
psd_all_c = psd_all_c[:, elevations, :]
psd_all_i = psd_all_i[:, elevations, :]
####### Map Learning #######
# filter data and integrate it for map learning
psd_mono, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
psd_all_i, psd_all_c, ear, normalization_type, sigma_smoothing,
sigma_gauss_norm)
# create map from defined processed data
if mean_subtracted_map:
learned_map = psd_binaural_mean.mean(0)
else:
learned_map = psd_binaural.mean(0)
####### Input Processing #######
# process data for actual input
psd_all_c, psd_all_i = generateData.create_data(
freq_bands, participant_number, snr, normalize, azimuth,
time_window)
# filter data and integrate it
psd_mono, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
psd_all_i, psd_all_c, ear, normalization_type, sigma_smoothing,
sigma_gauss_norm)
####### Localization #######
# localize the sounds and save the results
x_mono, y_mono = hp.localize_sound(psd_mono, learned_map)
# localize the sounds and save the results
x_mono_mean, y_mono_mean = hp.localize_sound(psd_mono_mean,
learned_map)
# localize the sounds and save the results
x_bin, y_bin = hp.localize_sound(psd_binaural, learned_map)
# localize the sounds and save the results
x_bin_mean, y_bin_mean = hp.localize_sound(psd_binaural_mean,
learned_map)
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([
x_mono, y_mono, x_mono_mean, y_mono_mean, x_bin, y_bin,
x_bin_mean, y_bin_mean
], f)
def main(model_name='different_learned_maps',
exp_name='localization_default',
azimuth=12,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False):
""" This script takes the filtered data and tries to localize sounds with different, learned map
for all participants.
"""
logger = logging.getLogger(__name__)
logger.info('Localizing sounds for all participants, different maps')
########################################################################
######################## Set parameters ################################
########################################################################
participant_numbers = np.array([
1, 2, 3, 8, 9, 10, 11, 12, 15, 17, 18, 19, 20, 21, 27, 28, 33, 40, 44,
48, 50, 51, 58, 59, 60, 61, 65, 119, 124, 126, 127, 131, 133, 134, 135,
137, 147, 148, 152, 153, 154, 155, 156, 158, 162, 163, 165
])
# participant_numbers = np.array([1, 2, 3, 8, 9, 10, 11,
# 12, 15, 17, 18, 19, 20,
# 21, 27, 28, 33, 40])
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file' + exp_file.as_posix())
[
x_mono, y_mono, x_mono_mean, y_mono_mean, x_bin, y_bin,
x_bin_mean, y_bin_mean
] = pickle.load(f)
else:
x_mono = np.zeros((4, len(participant_numbers), len(SOUND_FILES),
len(elevations), 2))
y_mono = np.zeros(
(4, len(participant_numbers), len(SOUND_FILES), len(elevations)))
x_mono_mean = np.zeros((4, len(participant_numbers), len(SOUND_FILES),
len(elevations), 2))
y_mono_mean = np.zeros(
(4, len(participant_numbers), len(SOUND_FILES), len(elevations)))
x_bin = np.zeros((4, len(participant_numbers), len(SOUND_FILES),
len(elevations), 2))
y_bin = np.zeros(
(4, len(participant_numbers), len(SOUND_FILES), len(elevations)))
x_bin_mean = np.zeros((4, len(participant_numbers), len(SOUND_FILES),
len(elevations), 2))
y_bin_mean = np.zeros(
(4, len(participant_numbers), len(SOUND_FILES), len(elevations)))
for i_par, par in enumerate(participant_numbers):
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(freq_bands,
par,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq,
diff_noise=False)
# Take only given elevations
psd_all_c = psd_all_c[:, elevations, :]
psd_all_i = psd_all_i[:, elevations, :]
# filter data and integrate it
psd_mono, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
psd_all_i, psd_all_c, ear, normalization_type, sigma_smoothing,
sigma_gauss_norm)
### Read different noise data ###
# create or read the data
psd_all_c_diff_noise, psd_all_i_diff_noise = generateData.create_data(
freq_bands,
par,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq,
diff_noise=True)
# Take only given elevations
psd_all_c_diff_noise = psd_all_c_diff_noise[:, elevations, :]
psd_all_i_diff_noise = psd_all_i_diff_noise[:, elevations, :]
# filter data and integrate it
psd_mono_diff_noise, psd_mono_mean_diff_noise, psd_binaural_diff_noise, psd_binaural_mean_diff_noise = hp.process_inputs(
psd_all_i_diff_noise, psd_all_c_diff_noise, ear,
normalization_type, sigma_smoothing, sigma_gauss_norm)
# walk over the 4 different maps: mono, mono_mean, bina, bina_mean
for i_map in range(4):
# create map from defined processed data
if i_map == 0:
learned_map = psd_mono.mean(0)
elif i_map == 1:
learned_map = psd_mono_mean.mean(0)
elif i_map == 2:
learned_map = psd_binaural.mean(0)
elif i_map == 3:
# bina_mean
learned_map = psd_binaural_mean.mean(0)
else:
logger.error('Something went wrong in if i_map statement')
# localize the sounds and save the results
x_mono[i_map,
i_par, :, :, :], y_mono[i_map,
i_par, :] = hp.localize_sound(
psd_mono_diff_noise,
learned_map)
# localize the sounds and save the results
x_mono_mean[i_map, i_par, :, :, :], y_mono_mean[
i_map,
i_par, :, :] = hp.localize_sound(psd_mono_mean_diff_noise,
learned_map)
# localize the sounds and save the results
x_bin[i_map,
i_par, :, :, :], y_bin[i_map,
i_par, :, :] = hp.localize_sound(
psd_binaural_diff_noise,
learned_map)
# localize the sounds and save the results
x_bin_mean[i_map, i_par, :, :, :], y_bin_mean[
i_map, i_par, :, :] = hp.localize_sound(
psd_binaural_mean_diff_noise, learned_map)
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([
x_mono, y_mono, x_mono_mean, y_mono_mean, x_bin, y_bin,
x_bin_mean, y_bin_mean
], f)
def main(model_name='map_learning',
exp_name='localization_all_maps',
azimuth=12,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
n_trials=100,
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False):
""" Learns the elevation spectra map gradually over presented sounds and saves the localization quality for each trial
"""
logger = logging.getLogger(__name__)
logger.info('Learning different maps for all participants')
########################################################################
######################## Set parameters ################################
########################################################################
# participant_numbers = np.array([1, 2, 3, 8, 9, 10, 11,
# 12, 15, 17, 18, 19, 20,
# 21, 27, 28, 33, 40, 44,
# 48, 50, 51, 58, 59, 60,
# 61, 65, 119, 124, 126,
# 127, 131, 133, 134, 135,
# 137, 147, 148, 152, 153,
# 154, 155, 156, 158, 162,
# 163, 165])
participant_numbers = np.array([
127,
131,
133,
134,
135,
])
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize,
len(elevations), ear, n_trials
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file')
[mono_res, mono_mean_res, bin_res, bin_mean_res,
trial_used_ss] = pickle.load(f)
else:
# store only the localization coefficeints (gain,bias,score)
mono_res = np.zeros((4, len(participant_numbers), n_trials, 3))
mono_mean_res = np.zeros((4, len(participant_numbers), n_trials, 3))
bin_res = np.zeros((4, len(participant_numbers), n_trials, 3))
bin_mean_res = np.zeros((4, len(participant_numbers), n_trials, 3))
trial_used_ss = np.zeros((4, len(participant_numbers), n_trials))
for i_par, par in enumerate(participant_numbers):
logger.info(
'Localizing {0:d} trials for participant {1:d}. \n'.format(
n_trials, par))
# create or read the data. psd_all_c = (sounds,elevations,frequency bands)
psd_all_c, psd_all_i = generateData.create_data(freq_bands,
par,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq,
diff_noise=False)
# Take only given elevations
psd_all_c = psd_all_c[:, elevations, :]
psd_all_i = psd_all_i[:, elevations, :]
# filter data and integrate it
psd_mono, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
psd_all_i, psd_all_c, ear, normalization_type, sigma_smoothing,
sigma_gauss_norm)
### Load different noise data ###
# create or read the data. psd_all_c = (sounds,elevations,frequency bands)
psd_all_c_diff_noise, psd_all_i_diff_noise = generateData.create_data(
freq_bands,
par,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq,
diff_noise=True)
# Take only given elevations
psd_all_c_diff_noise = psd_all_c_diff_noise[:, elevations, :]
psd_all_i_diff_noise = psd_all_i_diff_noise[:, elevations, :]
# filter data and integrate it
psd_mono_diff_noise, psd_mono_mean_diff_noise, psd_binaural_diff_noise, psd_binaural_mean_diff_noise = hp.process_inputs(
psd_all_i_diff_noise, psd_all_c_diff_noise, ear,
normalization_type, sigma_smoothing, sigma_gauss_norm)
# walk over test n_trials, in this case the number of sound samples
for i_trials in range(n_trials):
# decide how many sound samples should be used for the map. this is between 1 and number_of_sounds * number_of_elevations
number_of_ss = np.random.randint(
1, psd_all_c.shape[0] * psd_all_c.shape[1])
# choose the sound samples to learn the map
ind = np.random.randint(0,
high=(psd_all_c.shape[0] *
psd_all_c.shape[1]),
size=number_of_ss)
# get the indices for the sound_inds
sounds_ind = np.unravel_index(
ind, (psd_all_c.shape[0], psd_all_c.shape[1]))
# decide which type of map is learned_map
for i_maps in range(4):
# monaural condition
if i_maps == 0:
# get only the defined sounds and elevations
tmp_data = np.zeros(psd_mono.shape)
tmp_data[sounds_ind[0],
sounds_ind[1], :] = psd_mono[sounds_ind[0],
sounds_ind[1], :]
# create learned_map
learned_map = tmp_data.mean(0)
elif i_maps == 1:
# get only the defined sounds and elevations
tmp_data = np.zeros(psd_mono_mean.shape)
tmp_data[sounds_ind[0],
sounds_ind[1], :] = psd_mono_mean[
sounds_ind[0], sounds_ind[1], :]
# create learned_map
learned_map = tmp_data.mean(0)
elif i_maps == 2:
# get only the defined sounds and elevations
tmp_data = np.zeros(psd_binaural.shape)
tmp_data[sounds_ind[0],
sounds_ind[1], :] = psd_binaural[
sounds_ind[0], sounds_ind[1], :]
# create learned_map
learned_map = tmp_data.mean(0)
elif i_maps == 3:
# get only the defined sounds and elevations
tmp_data = np.zeros(psd_binaural_mean.shape)
tmp_data[sounds_ind[0],
sounds_ind[1], :] = psd_binaural_mean[
sounds_ind[0], sounds_ind[1], :]
# create learned_map
learned_map = tmp_data.mean(0)
# store the map
# learned_maps_participants[i_par, :, :] = learned_map
# store the number of sounds used
trial_used_ss[i_maps, i_par, i_trials] = number_of_ss
# localize the sounds and save the results
x, y = hp.localize_sound(psd_mono_diff_noise, learned_map)
mono_res[
i_maps, i_par,
i_trials, :] = hp.get_localization_coefficients_score(
x, y)
# localize the sounds and save the results
x, y = hp.localize_sound(psd_mono_mean_diff_noise,
learned_map)
mono_mean_res[
i_maps, i_par,
i_trials, :] = hp.get_localization_coefficients_score(
x, y)
# localize the sounds and save the results
x, y = hp.localize_sound(psd_binaural_diff_noise,
learned_map)
bin_res[
i_maps, i_par,
i_trials, :] = hp.get_localization_coefficients_score(
x, y)
# localize the sounds and save the results
x, y = hp.localize_sound(psd_binaural_mean_diff_noise,
learned_map)
bin_mean_res[
i_maps, i_par,
i_trials, :] = hp.get_localization_coefficients_score(
x, y)
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([
mono_res, mono_mean_res, bin_res, bin_mean_res, trial_used_ss
], f)
def main(model_name='hrtf_comparison',
exp_name='single_participant',
azimuth=12,
participant_number=9,
snr=0.0,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False):
""" This script calculates the correlation coefficient between the ipsi- and contralateral HRTF and the learned maps for a single participant.
"""
logger = logging.getLogger(__name__)
logger.info(
'Comparing learned HRTF maps with the actual HRTF of a participant')
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, participant_number,
(azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file')
[
hrtfs_i, hrtfs_c, learned_map_mono, learned_map_mono_mean,
learned_map_bin, learned_map_bin_mean
] = pickle.load(f)
else:
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(freq_bands,
participant_number,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq)
# filter data and integrate it
psd_mono, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
psd_all_i, psd_all_c, ear, normalization_type, sigma_smoothing,
sigma_gauss_norm)
# create map from defined processed data
learned_map_mono = psd_mono.mean(0)
learned_map_mono_mean = psd_mono_mean.mean(0)
learned_map_bin = psd_binaural.mean(0)
learned_map_bin_mean = psd_binaural_mean.mean(0)
# learned_map = hp.create_map(psd_mono, False)
# Get the actual HRTF
hrtfs_c, hrtfs_i, _ = generateHRTFs.create_data(freq_bands,
participant_number,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq,
clean=clean)
# filter data and integrate it
# hrtfs_c = hp.filter_dataset(hrtfs_c, normalization_type=normalization_type,
# sigma_smoothing=0, sigma_gauss_norm=0)
hrtfs_c, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
hrtfs_i, hrtfs_c, 'contra', normalization_type, sigma_smoothing,
sigma_gauss_norm)
hrtfs_i, psd_mono_mean, psd_binaural, psd_binaural_mean = hp.process_inputs(
hrtfs_i, hrtfs_c, 'ipsi', normalization_type, sigma_smoothing,
sigma_gauss_norm)
# remove mean for later comparison
hrtfs_c = np.squeeze(hrtfs_c[0, elevations, :])
hrtfs_c -= hrtfs_c.mean()
hrtfs_i = np.squeeze(hrtfs_i[0, elevations, :])
hrtfs_i -= hrtfs_i.mean()
# remove unwanted elevations
learned_map_mono = learned_map_mono[elevations, :]
learned_map_mono_mean = learned_map_mono_mean[elevations, :]
learned_map_bin = learned_map_bin[elevations, :]
learned_map_bin_mean = learned_map_bin_mean[elevations, :]
learned_map_mono -= learned_map_mono.mean()
learned_map_mono_mean -= learned_map_mono_mean.mean()
learned_map_bin -= learned_map_bin.mean()
learned_map_bin_mean -= learned_map_bin_mean.mean()
# ## calculate pearson index
# correlations[i_par, 0, 0] = pearson2d(learned_map_mono, hrtfs_i)
# correlations[i_par, 0, 1] = pearson2d(learned_map_mono, hrtfs_c)
#
# correlations[i_par, 1, 0] = pearson2d(
# learned_map_mono_mean, hrtfs_i)
# correlations[i_par, 1, 1] = pearson2d(
# learned_map_mono_mean, hrtfs_c)
#
# correlations[i_par, 2, 0] = pearson2d(learned_map_bin, hrtfs_i)
# correlations[i_par, 2, 1] = pearson2d(learned_map_bin, hrtfs_c)
#
# correlations[i_par, 3, 0] = pearson2d(
# learned_map_bin_mean, hrtfs_i)
# correlations[i_par, 3, 1] = pearson2d(
# learned_map_bin_mean, hrtfs_c)
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([
hrtfs_i, hrtfs_c, learned_map_mono, learned_map_mono_mean,
learned_map_bin, learned_map_bin_mean
], f)
def main(save_figs=False,
save_type='svg',
model_name='single_participant',
exp_name='single_participant_default',
azimuth=12,
participant_number=9,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1):
logger = logging.getLogger(__name__)
logger.info('Showing localization results for a single participant')
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, participant_number,
(azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[
localization_results_binaural, localization_results_monaural,
q_ele_all, r_ipsi_all
] = pickle.load(f)
fig = plt.figure(figsize=(20, 5))
axes = fig.subplots(1, 4, squeeze=False, sharex=False, sharey=False)
ax1 = axes[0, 0]
ax1.set_title('Monaural')
hp_vis.plot_localization_result(localization_results_monaural[:, :, 0],
localization_results_monaural[:, :, 1],
ax=ax1,
sound_files=SOUND_FILES,
scale_values=False,
disp_values=True)
# ax1.set_ylim([0,25])
# ax1.set_xlim([0,25])
ax1 = axes[0, 1]
ax1.set_title('Monaural - Prior ')
hp_vis.plot_localization_result(localization_results_monaural[:, :, 0],
localization_results_monaural[:, :, 2],
ax=ax1,
sound_files=SOUND_FILES,
scale_values=True,
disp_values=True)
# ax1.set_ylim([0,25])
# ax1.set_xlim([0,25])
ax1 = axes[0, 2]
ax1.set_title('Binaural')
hp_vis.plot_localization_result(localization_results_binaural[:, :, 0],
localization_results_binaural[:, :, 1],
ax=ax1,
sound_files=SOUND_FILES,
scale_values=True,
disp_values=True)
# ax1.set_ylim([0,25])
# ax1.set_xlim([0,25])
ax1 = axes[0, 3]
ax1.set_title('Binaural - Prior')
hp_vis.plot_localization_result(localization_results_binaural[:, :, 0],
localization_results_binaural[:, :, 2],
ax=ax1,
sound_files=SOUND_FILES,
scale_values=True,
disp_values=True)
# ax1.set_ylim([0,25])
# ax1.set_xlim([0,25])
plt.tight_layout()
if save_figs:
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
plt.savefig(
(fig_save_path / (model_name + '_' + exp_name +
'_localization.' + save_type)).as_posix(),
dpi=300)
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(save_figs=False, save_type='svg', model_name='all_participants', exp_name='localization_default', azimuth=12, freq_bands=24, max_freq=20000, elevations=25, snr=0.2, mean_subtracted_map=True, ear='ipsi', normalization_type='sum_1', sigma_smoothing=0, sigma_gauss_norm=1, clean=False):
logger = logging.getLogger(__name__)
logger.info('Showing localization results for all participants')
########################################################################
######################## Set parameters ################################
########################################################################
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
snrs = np.arange(0.0, 1.1, 0.1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm, mean_subtracted_map,
time_window, freq_bands, max_freq, (azimuth - 12) * 10, normalize, len(elevations), ear])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[scores] = pickle.load(f)
snrs_all = np.tile(snrs, (scores.shape[0], 1))
snrs_all = np.reshape(snrs_all, (snrs_all.shape[0] * snrs_all.shape[1]))
scores_tmp = np.reshape(scores, (scores.shape[0] * scores.shape[1], scores.shape[2], scores.shape[3]))
fig = plt.figure(figsize=(20, 7))
ax = fig.add_subplot(1, 3, 1)
y = scores_tmp[:, 0, 0]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C0, label='Mono')
y = scores_tmp[:, 1, 0]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C1, label='Mono-Mean')
y = scores_tmp[:, 2, 0]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C2, label='Bin')
y = scores_tmp[:, 3, 0]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C3, label='Bin-Mean')
ax.set_ylabel('Gain')
ax.set_xlabel('SNR')
ax.set_ylim([0.0, 1.1])
ax = fig.add_subplot(1, 3, 2)
y = scores_tmp[:, 0, 1]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C0, label='Mono')
y = scores_tmp[:, 1, 1]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C1, label='Mono-Mean')
y = scores_tmp[:, 2, 1]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C2, label='Bin')
y = scores_tmp[:, 3, 1]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C3, label='Bin-Mean')
ax.set_ylabel('Bias')
ax.set_xlabel('SNR')
ax.set_ylim([0.0, 30])
ax = fig.add_subplot(1, 3, 3)
y = scores_tmp[:, 0, 2]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C0, label='Monaural')
y = scores_tmp[:, 1, 2]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C1, label='Mono-Mean')
y = scores_tmp[:, 2, 2]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C2, label='Binaural')
y = scores_tmp[:, 3, 2]
sns.regplot(x=snrs_all, y=y, x_estimator=np.mean, order=2, ax=ax, color=hp_vis.C3, label='Bin-Mean')
ax.set_ylabel('Score')
ax.set_xlabel('SNR')
ax.set_ylim([0.0, 1.4])
lgd = ax.legend(loc='upper center', bbox_to_anchor=(1.35, 0.8))
plt.tight_layout()
if save_figs:
exp_name_str = hp.create_exp_name([exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm, mean_subtracted_map, time_window, int(
snr * 100), freq_bands, max_freq, (azimuth - 12) * 10, normalize, len(elevations), ear])
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
logger.info('Saving figures to ' + fig_save_path.as_posix())
plt.savefig((fig_save_path / (model_name + '_' + exp_name + '_localization.' + save_type)).as_posix(), dpi=300)
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
def main(model_name='train_network_single_participant',
exp_name='single_participant_default',
azimuth=12,
participant_number=9,
snr=0.0,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False,
steady_state=False):
""" This script takes the filtered data and tries to localize sounds with a learned map
for a single participant.
"""
logger = logging.getLogger(__name__)
logger.info('Localizing sounds for a single participant')
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, participant_number,
(azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / (exp_name_str + '_weights')
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file')
[w] = pickle.load(f)
else:
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(freq_bands,
participant_number,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq)
# Take only given elevations
input_c = psd_all_c[:, elevations, :]
input_i = psd_all_i[:, elevations, :]
# normalize inputs over frequencies
input_c = input_c / input_c.sum(2)[:, :, np.newaxis]
input_i = input_i / input_i.sum(2)[:, :, np.newaxis]
# initialize network. if steady_state is True run do not use euler but calculate the response immediatley
net = network.Network(steady_state=steady_state)
# if we use the steady state response to learn, we need more trials
if steady_state:
trials = 1500 * 10
else:
trials = 25
for ele in range(trials):
# for i_ele, ele in enumerate(elevations):
ele = np.random.randint(0, len(elevations))
sound = np.random.randint(0, len(SOUND_FILES))
# sound = 1
# ele = 1
in_i = input_i[sound, ele]
in_c = input_c[sound, ele]
q_ele, r_ipsi, w, w_sounds_i, w_sounds_c = net.run(in_i,
in_c,
ele,
sound,
train=True,
prior_info=True)
# logger.info('Sound No: ' + str(sound + 1) + ' of ' + str(len(SOUND_FILES)) +
# '. -> Elevation : ' + str(ele + 1) + ' of ' + str(len(elevations)))
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([w, w_sounds_i, w_sounds_c], f)
def main(model_name='localize_single_participant',
exp_name='single_participant_default',
azimuth=12,
participant_number=9,
snr=0.0,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1,
clean=False,
steady_state=False):
""" This script takes the filtered data and tries to localize sounds with a learned map
for a single participant.
"""
logger = logging.getLogger(__name__)
logger.info('Localizing sounds for a single participant')
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
# create unique experiment name
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, participant_number,
(azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# store responses
r_ipsi_all = np.zeros((len(SOUND_FILES), len(elevations), freq_bands))
q_ele_all = np.zeros((len(SOUND_FILES), len(elevations), len(elevations)))
localization_results_binaural = np.zeros(
(len(SOUND_FILES), len(elevations), 3))
localization_results_monaural = np.zeros(
(len(SOUND_FILES), len(elevations), 3))
# check if model results exist already and load
if not clean and exp_path.exists() and exp_file.is_file():
# try to load the model files
with exp_file.open('rb') as f:
logger.info('Reading model data from file')
[
localization_results_binaural, localization_results_monaural,
q_ele_all, r_ipsi_all
] = pickle.load(f)
else:
# create Path
exp_path.mkdir(parents=True, exist_ok=True)
# create or read the data
psd_all_c, psd_all_i = generateData.create_data(freq_bands,
participant_number,
snr,
normalize,
azimuth,
time_window,
max_freq=max_freq)
# Take only given elevations
input_c = psd_all_c[:, elevations, :]
input_i = psd_all_i[:, elevations, :]
# normalize inputs over frequencies
input_c = input_c / input_c.sum(2)[:, :, np.newaxis]
input_i = input_i / input_i.sum(2)[:, :, np.newaxis]
# initialize network. if steady_state is True run do not use euler but calculate the response immediatley
net = network.Network(steady_state=steady_state)
# read previously read network weights
exp_file_weights = Path(exp_file.as_posix() + '_weights')
with exp_file_weights.open('rb') as f:
logger.info('Reading model data from file')
[w, w_sounds_i, w_sounds_c] = pickle.load(f)
# normalize weights
net.w = net.normalize_weights(w)
net.w_sounds_i = w_sounds_i
net.w_sounds_c = w_sounds_c
############## MONAURAL #################
# walk over sounds
for sound, _ in enumerate(SOUND_FILES):
for i_ele, ele in enumerate(elevations):
in_i = input_i[sound, ele]
in_c = np.zeros(input_c[sound, ele].shape) + 0.1
# NO PRIOR
q_ele, r_ipsi, w, w_sounds_i, w_sounds_c = net.run(
in_i, in_c, ele, sound, train=False, prior_info=False)
# localize and save results
localization_results_monaural[sound, i_ele, 0] = ele
localization_results_monaural[sound, i_ele,
1] = q_ele[-1, :].argmax()
# PRIOR
q_ele, r_ipsi, w, w_sounds_i, w_sounds_c = net.run(
in_i, in_c, ele, sound, train=False, prior_info=True)
# localize and save results
localization_results_monaural[sound, i_ele,
2] = q_ele[-1, :].argmax()
############## BINAURAL #################
# walk over sounds
for sound, _ in enumerate(SOUND_FILES):
for i_ele, ele in enumerate(elevations):
in_i = input_i[sound, ele]
in_c = input_c[sound, ele]
# NO PRIOR
q_ele, r_ipsi, w, w_sounds_i, w_sounds_c = net.run(
in_i, in_c, ele, sound, train=False, prior_info=False)
# localize and save results
localization_results_binaural[sound, i_ele, 0] = ele
localization_results_binaural[sound, i_ele,
1] = q_ele[-1, :].argmax()
# PRIOR
q_ele, r_ipsi, w, w_sounds_i, w_sounds_c = net.run(
in_i, in_c, ele, sound, train=False, prior_info=True)
# localize and save results
localization_results_binaural[sound, i_ele,
2] = q_ele[-1, :].argmax()
with exp_file.open('wb') as f:
logger.info('Creating model file')
pickle.dump([
localization_results_binaural, localization_results_monaural,
q_ele_all, r_ipsi_all
], f)
def main(save_figs=False,
save_type='svg',
model_name='single_participant',
exp_name='single_participant_default',
azimuth=12,
participant_number=9,
snr=0.2,
freq_bands=24,
max_freq=20000,
elevations=25,
mean_subtracted_map=True,
ear='ipsi',
normalization_type='sum_1',
sigma_smoothing=0,
sigma_gauss_norm=1):
logger = logging.getLogger(__name__)
logger.info('Showing localization results for a single participant')
# make sure save type is given
if not save_type or len(save_type) == 0:
save_type = 'svg'
########################################################################
######################## Set parameters ################################
########################################################################
normalize = False
time_window = 0.1 # time window in sec
elevations = np.arange(0, elevations, 1)
########################################################################
########################################################################
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing, sigma_gauss_norm,
mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, participant_number,
(azimuth - 12) * 10, normalize,
len(elevations), ear
])
exp_path = ROOT / 'models' / model_name
exp_file = exp_path / exp_name_str
# check if model results exist already and load
if exp_path.exists() and exp_file.is_file():
# try to load the model files
with open(exp_file.as_posix(), 'rb') as f:
logger.info('Reading model data from file')
[
x_mono, y_mono, x_mono_mean, y_mono_mean, x_bin, y_bin,
x_bin_mean, y_bin_mean
] = pickle.load(f)
# define which elevations should be used
print(y_mono.shape)
x_mono = x_mono[:, elevations, :]
y_mono = y_mono[:, elevations]
x_mono_mean = x_mono_mean[:, elevations, :]
y_mono_mean = y_mono_mean[:, elevations]
x_bin = x_bin[:, elevations, :]
y_bin = y_bin[:, elevations]
x_bin_mean = x_bin_mean[:, elevations, :]
y_bin_mean = y_bin_mean[:, elevations]
fig = plt.figure(figsize=(20, 5))
# plt.suptitle('Single Participant')
# Monoaural Data (Ipsilateral), No Mean Subtracted
ax = fig.add_subplot(1, 4, 1)
hp_vis.plot_localization_result(x_mono,
y_mono,
ax,
SOUND_FILES,
scale_values=True,
linear_reg=True,
disp_values=True)
ax.set_title('Monoaural')
hp_vis.set_axis(ax, len(elevations))
ax.set_ylabel('Estimated Elevation [deg]')
ax.set_xlabel('True Elevation [deg]')
# Monoaural Data (Ipsilateral),Mean Subtracted
ax = fig.add_subplot(1, 4, 2)
hp_vis.plot_localization_result(x_mono_mean,
y_mono_mean,
ax,
SOUND_FILES,
scale_values=True,
linear_reg=True,
disp_values=True)
ax.set_title('Mono - Prior')
hp_vis.set_axis(ax, len(elevations))
ax.set_xlabel('True Elevation [deg]')
# Binaural Data (Ipsilateral), No Mean Subtracted
ax = fig.add_subplot(1, 4, 3)
hp_vis.plot_localization_result(x_bin,
y_bin,
ax,
SOUND_FILES,
scale_values=True,
linear_reg=True,
disp_values=True)
ax.set_title('Binaural')
hp_vis.set_axis(ax, len(elevations))
ax.set_xlabel('True Elevation [deg]')
# Binaural Data (Ipsilateral), Mean Subtracted
ax = fig.add_subplot(1, 4, 4)
hp_vis.plot_localization_result(x_bin_mean,
y_bin_mean,
ax,
SOUND_FILES,
scale_values=True,
linear_reg=True,
disp_values=True)
ax.set_title('Bin - Prior')
hp_vis.set_axis(ax, len(elevations))
ax.set_xlabel('True Elevation [deg]')
plt.tight_layout()
if save_figs:
exp_name_str = hp.create_exp_name([
exp_name, normalization_type, sigma_smoothing,
sigma_gauss_norm, mean_subtracted_map, time_window,
int(snr * 100), freq_bands, max_freq, (azimuth - 12) * 10,
normalize,
len(elevations), ear
])
fig_save_path = ROOT / 'reports' / 'figures' / exp_name_str / model_name
if not fig_save_path.exists():
fig_save_path.mkdir(parents=True, exist_ok=True)
plt.savefig(
(fig_save_path / (model_name + '_' + exp_name +
'_participant_' + str(participant_number) +
'_localization.' + save_type)).as_posix(),
dpi=300)
else:
plt.show()
else:
logger.error('No data set found. Run model first!')
logger.error(exp_file)
