def run(tsp=None, rs=None):
valid_tsps = list(sorted(load.database().keys())) if tsp == None else tsp
valid_rs = [
'auditory_spectrum', 'fourier_spectrum', 'auditory_strf',
'fourier_strf', 'auditory_spectrogram', 'fourier_spectrogram',
'auditory_mps', 'fourier_mps'
] if rs == None else rs
args = {
'timbre_spaces': valid_tsps,
'audio_representations': valid_rs,
'log_foldername': './out_aud_STRF_avg_time_decimate_allAt11/',
'reduce_strf': 'avg_time',
'test_args': {
'snd_crossval': False
},
'audio_args': {
'resampling_fs': 16000,
'duration': -1,
'duration_cut_decay': 0.05
},
'optim_args': {
'cost': 'correlation',
'loss': 'exp_sum',
'method': 'L-BFGS-B',
'init_sig_mean': 1.0,
'init_sig_var': 0.01,
'num_loops': 300,
'logging': True
},
}
start_time = time.time()
run_optimization(args)
print(time.strftime("%H:%M:%S", time.gmtime(time.time() - start_time)))
def run_optim_tests():
args = {
'timbre_spaces': list(sorted(load.database().keys())),
'audio_representations': [
'auditory_spectrum', 'fourier_spectrum', 'auditory_strf',
'fourier_strf', 'auditory_spectrogram', 'fourier_spectrogram',
'auditory_mps', 'fourier_mps'
],
'log_foldername': './outs/ts_crossval',
'audio_args': {
'resampling_fs': 16000,
'duration': 0.25,
'duration_cut_decay': 0.05
},
'optim_args': {
'cost': 'correlation',
'loss': 'exp_sum',
'method': 'L-BFGS-B',
'init_sig_mean': 1.0,
'init_sig_var': 0.01,
'num_loops': 1000,
'logging': True
},
}
start_time = time.time()
run_optimization(args)
print(time.strftime("%H:%M:%S", time.gmtime(time.time() - start_time)))
def print_corr(xk):
jns, jds = [], []
corr_sum = []
for tsp in args['timbre_spaces']:
dissimil_mat_tsp = load.timbrespace_dismatrix(tsp, load.database())
tab_red = np.loadtxt(log_foldername+'/../input_data/{}_{}_input_data.txt'.format(tsp, rs))
ndims, ninstrus = tab_red.shape[0], tab_red.shape[1]
no_samples = ninstrus * (ninstrus - 1) / 2
idx_triu = np.triu_indices(dissimil_mat_tsp.shape[0], k=1)
target_v = dissimil_mat_tsp[idx_triu]
mean_target = np.mean(target_v)
std_target = np.std(target_v)
kernel = np.zeros((ninstrus, ninstrus))
for i in range(ninstrus):
for j in range(i + 1, ninstrus):
kernel[i, j] = -np.sum(
np.power(
np.divide(tab_red[:, i] - tab_red[:, j],
(xk + np.finfo(float).eps)), 2))
kernel_v = kernel[idx_triu]
mean_kernel = np.mean(kernel_v)
std_kernel = np.std(kernel_v)
Jn = np.sum(np.multiply(kernel_v - mean_kernel, target_v - mean_target))
Jd = no_samples * std_target * std_kernel
corr_sum.append(Jn/Jd)
if not os.path.isfile(os.path.join(log_foldername, 'tmp.pkl')):
loop_cpt = 1
pickle.dump({'loop': loop_cpt, 'correlation': [np.mean(corr_sum)]}, open(os.path.join(log_foldername, 'tmp.pkl'), 'wb'))
correlations = [np.mean(corr_sum)]
pickle.dump({
'sigmas': xk,
'kernel': kernel,
'Jn': Jn,
'Jd': Jd,
'corr_sum': corr_sum,
'correlations': correlations,
}, open(os.path.join(log_foldername,
'optim_process_l={}.pkl'.format(loop_cpt)), 'wb'))
else:
last_loop = pickle.load(open(os.path.join(log_foldername,'tmp.pkl'), 'rb'))
loop_cpt = last_loop['loop'] + 1
correlations = last_loop['correlation']
correlations.append(np.mean(corr_sum))
monitoring_step = 50
if (loop_cpt % monitoring_step == 0):
corr_sum_str = ' '.join(['{:.2f}'.format(c) for c in corr_sum])
print(' |_ loop={} J={:.6f} ({})'.format(loop_cpt, np.mean(corr_sum), corr_sum_str))
pickle.dump({
'sigmas': xk,
'kernel': kernel,
'Jn': Jn,
'Jd': Jd,
'corr_sum': corr_sum,
'correlations': correlations,
}, open(os.path.join(log_foldername,
'optim_process_l={}.pkl'.format(loop_cpt)), 'wb'))
pickle.dump({'loop': loop_cpt, 'correlation': correlations, 'sigmas': xk}, open(os.path.join(log_foldername, 'tmp.pkl'), 'wb'))
def corr(x):
corr_sum = 0
for tsp in args['timbre_spaces']:
dissimil_mat_tsp = load.timbrespace_dismatrix(tsp, load.database())
tab_red = np.loadtxt(log_foldername+'/../input_data/{}_{}_input_data.txt'.format(tsp, rs))
# tab_red = np.loadtxt('input_data/{}_{}_input_data.txt'.format(tsp, rs))
ndims, ninstrus = tab_red.shape[0], tab_red.shape[1]
no_samples = ninstrus * (ninstrus - 1) / 2
idx_triu = np.triu_indices(dissimil_mat_tsp.shape[0], k=1)
target_v = dissimil_mat_tsp[idx_triu]
mean_target = np.mean(target_v)
std_target = np.std(target_v)
kernel = np.zeros((ninstrus, ninstrus))
for i in range(ninstrus):
for j in range(i + 1, ninstrus):
kernel[i, j] = -np.sum(
np.power(
np.divide(tab_red[:, i] - tab_red[:, j],
(x + np.finfo(float).eps)), 2))
kernel_v = kernel[idx_triu]
mean_kernel = np.mean(kernel_v)
std_kernel = np.std(kernel_v)
Jn = np.sum(np.multiply(kernel_v - mean_kernel, target_v - mean_target))
Jd = no_samples * std_target * std_kernel
corr_sum += Jn/Jd
return corr_sum
def compute_representations():
args = {
'timbre_spaces': list(sorted(load.database().keys())),
'audio_representations': [
'auditory_spectrum', 'fourier_spectrum', 'auditory_strf',
'fourier_strf', 'auditory_spectrogram', 'fourier_spectrogram',
'auditory_mps', 'fourier_mps'
],
'log_foldername': './outs/ts_crossval',
'audio_args': {
'resampling_fs': 16000,
'duration': 0.25,
'duration_cut_decay': 0.05
}
}
log_foldername = args['log_foldername']
print('--processing')
for i, tsp in enumerate(args['timbre_spaces']):
print('Processing', tsp)
subprocess.call(['mkdir', '-p', log_foldername+'/input_data'])
for rs in args['audio_representations']:
aud_repres = load.timbrespace_features(tsp, representations=[rs], audio_args=args['audio_args'])[rs]
tab_red = []
rs_type = rs.split('_')[-1]
mapping = []
variances = []
if rs_type == 'strf':
n_components = 1
for i in range(len(aud_repres)):
strf_reduced, mapping_, variances = pca.pca_patil(
np.absolute(aud_repres[i]),
aud_repres[i].shape[1],
n_components=n_components)
strf_reduced = strf_reduced.flatten()
tab_red.append(strf_reduced)
mapping.append(mapping_)
tab_red = np.transpose(np.asarray(tab_red))
elif rs_type == 'spectrogram' or rs_type == 'mps':
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i].flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif rs_type == 'spectrum':
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i])
tab_red = np.transpose(np.asarray(tab_red))
np.savetxt(log_foldername+'/input_data/{}_{}_input_data.txt'.format(tsp, rs), tab_red)
print('--normalising')
for rs in args['audio_representations']:
print('Processing', rs)
normas = []
for i, tsp in enumerate(args['timbre_spaces']):
data = np.loadtxt(log_foldername+'/input_data/{}_{}_input_data.txt'.format(tsp, rs))
normas.append(np.mean(np.max(np.abs(data), axis=0)))
for i, tsp in enumerate(args['timbre_spaces']):
data = np.loadtxt(log_foldername+'/input_data/{}_{}_input_data.txt'.format(tsp, rs))
data = data / np.mean(normas)
# print(' save final data {} {:.5f}'.format(data.shape, np.mean(normas)))
np.savetxt(log_foldername+'/input_data/{}_{}_input_data.txt'.format(tsp, rs), data)
def run_one_tsp_rs(tsp, rs, args):
rslog_foldername = args['optim_args']['log_foldername']
rs = rslog_foldername.split('/')[-1].split('-')[0]
dissimil_mat = load.timbrespace_dismatrix(tsp, load.database())
aud_repres = load.timbrespace_features(tsp,
representations=[rs],
audio_args=args['audio_args'])[rs]
tab_red = []
rs_type = rs.split('_')[-1]
mapping = []
variances = []
if rs_type == 'strf':
n_components = 1
for i in range(len(aud_repres)):
strf_reduced, mapping_, variances = pca.pca_patil(
np.absolute(aud_repres[i]),
aud_repres[i].shape[1],
n_components=n_components)
strf_reduced = strf_reduced.flatten()
tab_red.append(strf_reduced)
mapping.append(mapping_)
tab_red = np.transpose(np.asarray(tab_red))
elif rs_type == 'spectrogram' or rs_type == 'mps':
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i].flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif rs_type == 'spectrum':
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i])
tab_red = np.transpose(np.asarray(tab_red))
pickle.dump(
{
'data_repres': aud_repres,
'data_proj': tab_red,
'mapping': mapping,
'variances': variances,
'dissimilarities': dissimil_mat,
'audio_args': args['audio_args']
}, open(os.path.join(rslog_foldername, 'dataset.pkl'), 'wb'))
print(' data dimension:', tab_red.shape)
print('* normalizing')
tab_red = tab_red / np.mean(np.max(np.abs(tab_red), axis=0))
correlations, _ = training.kernel_optim_lbfgs_log(tab_red, dissimil_mat,
**args['optim_args'])
def grad_corr(x):
corr_sum = 0
for tsp_i, tsp in enumerate(args['timbre_spaces']):
dissimil_mat_tsp = load.timbrespace_dismatrix(tsp, load.database())
tab_red = np.loadtxt(log_foldername+'/../input_data/{}_{}_input_data.txt'.format(tsp, rs)) #np.loadtxt('input_data/{}_{}_input_data.txt'.format(tsp, rs))
# tab_red = np.loadtxt('input_data/{}_{}_input_data.txt'.format(tsp, rs))
ndims, ninstrus = tab_red.shape[0], tab_red.shape[1]
no_samples = ninstrus * (ninstrus - 1) / 2
idx_triu = np.triu_indices(dissimil_mat_tsp.shape[0], k=1)
target_v = dissimil_mat_tsp[idx_triu]
mean_target = np.mean(target_v)
std_target = np.std(target_v)
if tsp_i==0:
gradients = np.zeros((ndims, 1))
kernel = np.zeros((ninstrus, ninstrus))
dkernel = np.zeros((ninstrus, ninstrus, ndims))
for i in range(ninstrus):
for j in range(i + 1, ninstrus):
kernel[i, j] = -np.sum(
np.power(
np.divide(tab_red[:, i] - tab_red[:, j],
(x + np.finfo(float).eps)), 2))
dkernel[i, j, :] = 2 * np.power((tab_red[:, i] - tab_red[:, j]), 2) / (np.power(x, 3) + np.finfo(float).eps)
kernel_v = kernel[idx_triu]
mean_kernel = np.mean(kernel_v)
std_kernel = np.std(kernel_v)
Jn = np.sum(np.multiply(kernel_v - mean_kernel, target_v - mean_target))
Jd = no_samples * std_target * std_kernel
for k in range(ndims):
dkernel_k_v = dkernel[:, :, k][idx_triu]
dJn = np.sum(dkernel_k_v * (target_v - mean_target))
dJd = no_samples / no_samples * \
std_target / (std_kernel + np.finfo(float).eps) * \
np.sum(dkernel_k_v * (kernel_v - mean_kernel))
gradients[k] += (Jd * dJn - Jn * dJd) / (np.power(Jd,2) + np.finfo(float).eps)
return gradients
def run(tsp=None, rs=None):
valid_tsps = list(sorted(load.database().keys())) if tsp == None else tsp
valid_rs = [
'auditory_spectrum', 'fourier_spectrum', 'auditory_strf',
'fourier_strf', 'auditory_spectrogram', 'fourier_spectrogram',
'auditory_mps', 'fourier_mps'
] if rs == None else rs # valid representation name
args = {
'timbre_spaces': valid_tsps,
'audio_representations': valid_rs,
'log_foldername': './out_aud_STRF_avgTime/', # output folder
'reduce_strf': 'avg_time',
# type of averaging
# avg_time : STRF averaged over time,
# avg_time_avg_scale_rate_freqavg_time_avg_freq : STRF averaged over time and freq => scale/rate projection
# avg_time_avg_scale : STRF averaged over time and scale => freq/rate projection
# avg_time_avg_rate : STRF averaged over time and rate => freq/scale projection
'test_args': {
'snd_crossval': False
},
'audio_args': {
'resampling_fs': 16000, # resampling frequency
'duration': -1, # duration of the cut in seconds, -1 : no cut
'duration_cut_decay': 0.05 # duration of the fade out
},
'optim_args': {
'cost': 'correlation', # type of cost function
'loss': 'exp_sum', # loss type
'method': 'L-BFGS-B', # optimization method
'init_sig_mean': 1.0, # initial sigma mean
'init_sig_var': 0.01, # initial sigma variance
'num_loops': 300, # number of maximum iterations
'logging': True
},
}
start_time = time.time()
run_optimization(args)
print(time.strftime("%H:%M:%S", time.gmtime(time.time() - start_time)))
import matplotlib.pylab as plt
from lib import load
# def viz_single_corr(folder = 'outs/validtests_06-21-2018/grey1978/fourier_spectrum-180621@005541'):
# optim = pickle.load(open(os.path.join(folder, 'optim_process_l=1000.pkl'), 'rb'))
# plt.plot(optim['correlations'])
# plt.show()
# def viz_single_sigmas(folder = 'outs/grey1977/auditory_strf-180622@142544'):
# optim = pickle.load(open(os.path.join(folder, 'optim_process_l=400.pkl'), 'rb'))
# plt.plot(optim['sigmas'])
# plt.show()
timbre_spaces= list(sorted(load.database().keys()))
audio_representations = sorted([
'auditory_spectrum', 'fourier_spectrum', 'auditory_strf',
'fourier_strf', 'auditory_spectrogram', 'fourier_spectrogram',
'auditory_mps', 'fourier_mps'
])
def correlation_between_timbrespaces(res_path='outs/validtests_06-21-2018'):
timbrespaces = []
representations = []
loops = {}
sigmas = {}
for root, dirs, files in os.walk(res_path):
for f in files:
if 'optim_process' in f:
def run_one_tsp_rs(tsp, rs, args):
rslog_foldername = args['optim_args']['log_foldername']
rs = rslog_foldername.split('/')[-1].split('-')[0]
dissimil_mat = load.timbrespace_dismatrix(tsp, load.database())
aud_repres = load.timbrespace_features(tsp,
representations=[rs],
audio_args=args['audio_args'])[rs]
tab_red = []
rs_type = rs.split('_')[-1]
mapping = []
variances = []
reduce_strf = args['reduce_strf']
if rs_type == 'strf':
if reduce_strf == 'pca':
n_components = 1
for i in range(len(aud_repres)):
strf_reduced, mapping_, variances = pca.pca_patil(
np.absolute(aud_repres[i]),
aud_repres[i].shape[1],
n_components=n_components)
strf_reduced = strf_reduced.flatten()
tab_red.append(strf_reduced)
mapping.append(mapping_)
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time':
for i in range(len(aud_repres)):
strf_avgTime = np.mean(np.abs(aud_repres[i]), axis=0)
freqVec = [0, 14, 28, 42, 56, 71, 85, 99, 113, 127]
rateVec = [0, 3, 5, 7, 10, 11, 14, 16, 18, 21]
scaleVec = [0, 2, 3, 4, 5, 6, 7, 8, 9, 10]
indexedTab = strf_avgTime[freqVec, :, :][:,
scaleVec, :][:, :,
rateVec]
tab_red.append(indexedTab.flatten()) # decimation here
# [0:128:12,0:11,0:22:2]
# tab_red.append(strf_avgTime[0:128:12,0:11,0:22:2].flatten()) # decimation here
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time_avg_scale_rate_freq':
for i in range(len(aud_repres)):
tab_red.append(strf2avgvec(aud_repres[i]).flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time_avg_freq':
for i in range(len(aud_repres)):
strf_avgTime = np.mean(np.abs(aud_repres[i]), axis=0)
freqVec = [0, 14, 28, 42, 56, 71, 85, 99, 113, 127]
rateVec = [0, 3, 5, 7, 10, 11, 14, 16, 18, 21]
scaleVec = [0, 2, 3, 4, 5, 6, 7, 8, 9, 10]
indexedTab = strf_avgTime[freqVec, :, :][:,
scaleVec, :][:, :,
rateVec]
strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(
strf2avgvec(indexedTab),
nbChannels=10,
nbRates=10,
nbScales=10)
tab_red.append(strf_scale_rate.flatten())
# strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(strf2avgvec(aud_repres[i]))
# plotStrfavg(strf_scale_rate, strf_freq_rate, strf_freq_scale)
# tab_red.append(np.absolute(np.mean(aud_repres[i], axis=0)).flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time_avg_scale':
for i in range(len(aud_repres)):
strf_avgTime = np.mean(np.abs(aud_repres[i]), axis=0)
freqVec = [0, 14, 28, 42, 56, 71, 85, 99, 113, 127]
rateVec = [0, 3, 5, 7, 10, 11, 14, 16, 18, 21]
scaleVec = [0, 2, 3, 4, 5, 6, 7, 8, 9, 10]
indexedTab = strf_avgTime[freqVec, :, :][:,
scaleVec, :][:, :,
rateVec]
strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(
strf2avgvec(indexedTab),
nbChannels=10,
nbRates=10,
nbScales=10)
tab_red.append(strf_freq_rate.flatten())
# strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(strf2avgvec(aud_repres[i]))
# plotStrfavg(strf_scale_rate, strf_freq_rate, strf_freq_scale)
# tab_red.append(np.absolute(np.mean(aud_repres[i], axis=0)).flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time_avg_rate':
for i in range(len(aud_repres)):
strf_avgTime = np.mean(np.abs(aud_repres[i]), axis=0)
freqVec = np.array([0, 14, 28, 42, 56, 71, 85, 99, 113, 127])
rateVec = np.array([0, 3, 5, 7, 10, 11, 14, 16, 18, 21])
scaleVec = np.array([0, 2, 3, 4, 5, 6, 7, 8, 9, 10])
strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(
strf2avgvec(strf_avgTime[freqVec, scaleVec, rateVec]),
nbChannels=10,
nbRates=10,
nbScales=10)
tab_red.append(strf_freq_scale.flatten())
# strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(strf2avgvec(aud_repres[i]))
# plotStrfavg(strf_scale_rate, strf_freq_rate, strf_freq_scale)
# tab_red.append(np.absolute(np.mean(aud_repres[i], axis=0)).flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time_avg_SRSFFR':
for i in range(len(aud_repres)):
strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(
strf2avgvec(aud_repres[i]))
concat_tab = np.concatenate(
(strf_scale_rate, strf_freq_rate, strf_freq_scale),
axis=None)
tab_red.append(concat_tab.flatten())
# strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(strf2avgvec(aud_repres[i]))
# plotStrfavg(strf_scale_rate, strf_freq_rate, strf_freq_scale)
# tab_red.append(np.absolute(np.mean(aud_repres[i], axis=0)).flatten())
tab_red = np.transpose(np.asarray(tab_red))
else:
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i].flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif rs_type == 'spectrogram' or rs_type == 'mps':
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i].flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif rs_type == 'spectrum':
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i])
tab_red = np.transpose(np.asarray(tab_red))
# print(tab_red)
# print(aud_repres)
# print(mapping)
# print(variances)
# print(dissimil_mat)
print(args['audio_args'])
# pickle.dump({
# 'data_repres': aud_repres,
# 'data_proj': tab_red,
# 'mapping': mapping,
# 'variances': variances,
# 'dissimilarities': dissimil_mat,
# 'audio_args': args['audio_args']
# }, open(os.path.join(rslog_foldername, 'dataset.pkl'), 'wb'))
print(' data dimension:', tab_red.shape)
print('* normalizing')
print(np.mean(np.max(np.abs(tab_red), axis=0)))
tab_red = tab_red / np.mean(np.max(np.abs(tab_red), axis=0))
correlations, sigmas__ = training.kernel_optim_lbfgs_log(
tab_red, dissimil_mat, **args['optim_args'])
# strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(sigmas__)
# plotStrfavg(strf_scale_rate, strf_freq_rate, strf_freq_scale,show='false',figname=tsp+'_'+str(correlations[-1]))
pickle.dump(
{
'sigmas': sigmas__,
'representations': tab_red,
'dissimilarities': dissimil_mat,
'audio_args': args['audio_args']
},
open(
os.path.join(args['log_foldername'] + 'resultsOptims_' + rs_type +
'_' + reduce_strf + '_' + tsp + '.pkl'), 'wb'))
def run_one_tsp_rs_crossval(tsp, rs, args):
rslog_foldername = args['optim_args']['log_foldername']
rs = rslog_foldername.split('/')[-1].split('-')[0]
dissimil_mat = load.timbrespace_dismatrix(tsp, load.database())
aud_repres = load.timbrespace_features(tsp,
representations=[rs],
audio_args=args['audio_args'])[rs]
tab_red = []
rs_type = rs.split('_')[-1]
mapping = []
variances = []
reduce_strf = args['reduce_strf']
if rs_type == 'strf':
if reduce_strf == 'pca':
n_components = 1
for i in range(len(aud_repres)):
strf_reduced, mapping_, variances = pca.pca_patil(
np.absolute(aud_repres[i]),
aud_repres[i].shape[1],
n_components=n_components)
strf_reduced = strf_reduced.flatten()
tab_red.append(strf_reduced)
mapping.append(mapping_)
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time':
for i in range(len(aud_repres)):
tab_red.append(
np.absolute(np.mean(aud_repres[i], axis=0)).flatten())
tab_red = np.transpose(np.asarray(tab_red))
else:
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i].flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif rs_type == 'spectrogram' or rs_type == 'mps':
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i].flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif rs_type == 'spectrum':
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i])
tab_red = np.transpose(np.asarray(tab_red))
pickle.dump(
{
'data_repres': aud_repres,
'data_proj': tab_red,
'mapping': mapping,
'variances': variances,
'dissimilarities': dissimil_mat,
'audio_args': args['audio_args']
}, open(os.path.join(rslog_foldername, 'dataset.pkl'), 'wb'))
print(' data dimension:', tab_red.shape)
print('* normalizing')
tab_red = tab_red / np.mean(np.max(np.abs(tab_red), axis=0))
ninstrus = tab_red.shape[1]
correlations_training = []
sigmas_training = []
correlations_testing = []
correlations_testing_pearson = []
correlations_testing_spearman = []
sigmas_testing = []
distances_testing = []
target_testing = []
print('* cross-validation tests')
org_fname = args['optim_args']['log_foldername']
for fold in range(ninstrus):
# training data
train_idx = [i for i in range(tab_red.shape[1]) if i != fold]
sorted_train_idx = sorted(train_idx)
input_data_training = tab_red[:, train_idx]
target_data_training = dissimil_mat[train_idx, :]
target_data_training = target_data_training[:, train_idx]
# testing data
test_idx = [fold]
input_data_testing = tab_red[:, test_idx[0]]
target_data_testing = np.zeros((ninstrus - 1, 1))
cpt_i = 0
for i in range(ninstrus):
if i > test_idx[0]:
target_data_testing[cpt_i] = dissimil_mat[test_idx[0], i]
cpt_i += 1
elif i < test_idx[0]:
target_data_testing[cpt_i] = dissimil_mat[i, test_idx[0]]
cpt_i += 1
target_testing.append(target_data_testing.reshape(1, -1))
mean_target_test = np.mean(target_data_testing)
std_target_test = np.std(target_data_testing)
# optimisation on fold i
print('* Fold {} - {} {}'.format(fold + 1, train_idx, test_idx))
args['optim_args']['allow_resume'] = False
args['optim_args']['log_foldername'] = org_fname + '/fold{}'.format(
fold + 1)
subprocess.call(['mkdir', '-p', args['optim_args']['log_foldername']])
correlations, sigmas = training.kernel_optim_lbfgs_log(
input_data=input_data_training,
target_data=target_data_training,
test_data=(input_data_testing, target_data_testing),
**args['optim_args'])
correlations_training.append(correlations)
sigmas_training.append(sigmas)
distances = np.zeros((ninstrus - 1, 1))
for i in range(ninstrus - 1):
distances[i, 0] = -np.sum(
np.power(
np.divide(
tab_red[:, test_idx[0]] -
tab_red[:, sorted_train_idx[i]],
(sigmas + np.finfo(float).eps)), 2))
distances_testing.append(distances.reshape(1, -1))
mean_distances = np.mean(distances)
stddev_distances = np.std(distances)
Jn = np.sum(
np.multiply(distances - mean_distances,
target_data_testing - mean_target_test))
Jd = std_target_test * stddev_distances * (ninstrus - 1)
correlations_testing.append(Jn / Jd)
sigmas_testing.append(sigmas)
pearsr = pearsonr(distances, target_data_testing)
correlations_testing_pearson.append(pearsr)
spear_rho, spear_p_val = spearmanr(distances, target_data_testing)
spear = [spear_rho, spear_p_val]
correlations_testing_spearman.append(spear)
print('\tFold={} test_corr={:.3f} (PE {} | SP {}) (train_corr={:.3f})'.
format(fold + 1, Jn / Jd, pearsr, spear, correlations[-1]))
pickle.dump(
{
'correlations_training': correlations_training,
'sigmas_training': sigmas_training,
'correlations_testing': correlations_testing,
'sigmas_testing': sigmas_testing,
'correlations_testing_pearson': correlations_testing_pearson,
'correlations_testing_spearman': correlations_testing_spearman,
'distances_testing': distances_testing,
'target_data_testing': target_testing
},
open(os.path.join(rslog_foldername, 'crossval_intrats_res.pkl'),
'wb'))
mean_correlations_training = [
correlations_training[i][-1] for i in range(len(correlations_training))
]
mean_correlations_training = np.mean(mean_correlations_training)
distances_testing = np.squeeze(np.array(distances_testing)).reshape(-1, 1)
target_testing = np.squeeze(np.array(target_testing)).reshape(-1, 1)
print(
'\tAll Folds: mean_training_corr={} | corr_testing_pears={} | corr_testing_spear={}'
.format(mean_correlations_training,
pearsonr(distances_testing[:, 0], target_testing[:, 0]),
spearmanr(distances_testing[:, 0], target_testing[:, 0])))
# Copyright (c) Baptiste Caramiaux, Etienne Thoret
# All rights reserved
import numpy as np
import matplotlib.pylab as plt
import os
import pickle
import pca
# from optimization import kernel_optim
from lib import load
from lib import training
import time
import subprocess
timbrespace_db = load.database()
representations = [
# 'auditory_spectrum',
# 'fourier_spectrum',
# 'auditory_strf',
# 'fourier_strf',
# 'auditory_spectrogram',
'fourier_spectrogram',
# 'auditory_mps',
# 'fourier_mps',
]
def run_once(tsp, rs, optim_args):
rslog_foldername = optim_args['log_foldername']
rs = rslog_foldername.split('/')[-1].split('-')[0]
dissimil_mat = load.timbrespace_dismatrix(tsp, timbrespace_db)
aud_repres = load.timbrespace_features(
def run_one_tsp_rs_crossval(tsp, rs, args):
rslog_foldername = args['optim_args']['log_foldername']
rs = rslog_foldername.split('/')[-1].split('-')[0]
dissimil_mat = load.timbrespace_dismatrix(tsp, load.database())
aud_repres = load.timbrespace_features(tsp,
representations=[rs],
audio_args=args['audio_args'])[rs]
tab_red = []
rs_type = rs.split('_')[-1]
mapping = []
variances = []
if rs_type == 'strf':
n_components = 1
for i in range(len(aud_repres)):
strf_reduced, mapping_, variances = pca.pca_patil(
np.absolute(aud_repres[i]),
aud_repres[i].shape[1],
n_components=n_components)
strf_reduced = strf_reduced.flatten()
tab_red.append(strf_reduced)
mapping.append(mapping_)
tab_red = np.transpose(np.asarray(tab_red))
elif rs_type == 'spectrogram' or rs_type == 'mps':
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i].flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif rs_type == 'spectrum':
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i])
tab_red = np.transpose(np.asarray(tab_red))
pickle.dump(
{
'data_repres': aud_repres,
'data_proj': tab_red,
'mapping': mapping,
'variances': variances,
'dissimilarities': dissimil_mat,
'audio_args': args['audio_args']
}, open(os.path.join(rslog_foldername, 'dataset.pkl'), 'wb'))
print(' data dimension:', tab_red.shape)
print('* normalizing')
tab_red = tab_red / np.mean(np.max(np.abs(tab_red), axis=0))
corr_fold = []
sigmas_fold = []
print('* cross-validation tests')
for fold in range(20):
idx = [i for i in range(tab_red.shape[1])]
random.shuffle(idx)
train_idx = idx[:int(2 * len(idx) / 3)]
test_idx = idx[int(2 * len(idx) / 3):]
dmat = dissimil_mat[train_idx, :]
dmat = dmat[:, train_idx]
print('* Fold {} - {} {}'.format(fold + 1, train_idx, test_idx))
correlations, sigmas = training.kernel_optim_lbfgs_log(
tab_red[:, train_idx], dmat, **args['optim_args'])
# testing
test_data = tab_red[:, test_idx]
dmat = dissimil_mat[test_idx, :]
target_test_data = dmat[:, test_idx]
idx_triu = np.triu_indices(target_test_data.shape[0], k=1)
target_test_data_v = target_test_data[idx_triu]
mean_target_test = np.mean(target_test_data_v)
std_target_test = np.std(target_test_data_v)
ninstrus = len(test_idx)
no_samples = ninstrus * (ninstrus - 1) / 2
kernel = np.zeros((ninstrus, ninstrus))
for i in range(ninstrus):
for j in range(i + 1, ninstrus):
kernel[i, j] = -np.sum(
np.power(
np.divide(test_data[:, i] - test_data[:, j],
(sigmas + np.finfo(float).eps)), 2))
kernel_v = kernel[idx_triu]
mean_kernel = np.mean(kernel_v)
std_kernel = np.std(kernel_v)
Jn = np.sum(
np.multiply(kernel_v - mean_kernel,
target_test_data_v - mean_target_test))
Jd = no_samples * std_target_test * std_kernel
corr_fold.append(Jn / Jd)
sigmas_fold.append(sigmas)
print('\tfold={} corr={}'.format(fold + 1, Jn / Jd))
pickle.dump({
'corr_fold': corr_fold,
'sigmas_fold': sigmas_fold
}, open(os.path.join(rslog_foldername, 'crossval_res.pkl'), 'wb'))
print('\tall folds: corr={} ({})'.format(np.mean(corr_fold),
np.std(corr_fold)))
def run_one_tsp_rs(tsp, rs, args):
rslog_foldername = args['optim_args']['log_foldername'] # logfolder
rs = rslog_foldername.split('/')[-1].split('-')[0]
dissimil_mat = load.timbrespace_dismatrix(
tsp, load.database()) # load dissimilarity matrix
aud_repres = load.timbrespace_features(
tsp, representations=[rs],
audio_args=args['audio_args'])[rs] # load representations
tab_red = []
rs_type = rs.split('_')[-1]
mapping = []
variances = []
reduce_strf = args['reduce_strf']
if rs_type == 'strf': # parse the type of input representation
if reduce_strf == 'avg_time':
for i in range(len(aud_repres)):
strf_avgTime = np.mean(np.abs(aud_repres[i]), axis=0)
tab_red.append(strf_avgTime.flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time_avg_scale_rate_freq':
for i in range(len(aud_repres)):
tab_red.append(strf2avgvec(aud_repres[i]).flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time_avg_freq':
for i in range(len(aud_repres)):
strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(
strf2avgvec(aud_repres[i]))
tab_red.append(strf_scale_rate.flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time_avg_scale':
for i in range(len(aud_repres)):
strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(
strf2avgvec(aud_repres[i]))
tab_red.append(strf_freq_rate.flatten())
tab_red = np.transpose(np.asarray(tab_red))
elif reduce_strf == 'avg_time_avg_rate':
for i in range(len(aud_repres)):
strf_scale_rate, strf_freq_rate, strf_freq_scale = avgvec2strfavg(
strf2avgvec(aud_repres[i]))
tab_red.append(strf_freq_scale.flatten())
tab_red = np.transpose(np.asarray(tab_red))
else:
for i in range(len(aud_repres)):
tab_red.append(aud_repres[i].flatten())
tab_red = np.transpose(np.asarray(tab_red))
print(args['audio_args'])
print(' data dimension:', tab_red.shape)
print('* normalizing')
print(tab_red)
print(np.mean(np.max(np.abs(tab_red), axis=0)).shape)
tab_red = tab_red / np.mean(np.max(np.abs(tab_red), axis=0))
correlations, sigmas__ = training.kernel_optim_lbfgs_log(
tab_red, dissimil_mat, **args['optim_args'])
pickle.dump(
{
'sigmas': sigmas__,
'representations': tab_red,
'dissimilarities': dissimil_mat,
'audio_args': args['audio_args']
},
open(
os.path.join(args['log_foldername'] + 'resultsOptims_' + rs_type +
'_' + reduce_strf + '_' + tsp + '.pkl'), 'wb'))
def run_crossts(rs, args):
rslog_foldername = args['optim_args']['log_foldername']
rs = rslog_foldername.split('/')[-1].split('-')[0]
print('Audio representation:', rs)
cost=args['optim_args']['cost']
loss=args['optim_args']['loss']
init_sig_mean=args['optim_args']['init_sig_mean']
init_sig_var=args['optim_args']['init_sig_var']
num_loops=args['optim_args']['num_loops']
method='L-BFGS-B'
log_foldername=rslog_foldername
logging=args['optim_args']['logging']
verbose=True
tsp = args['timbre_spaces'][0]
dissimil_mat_tsp = load.timbrespace_dismatrix(tsp, load.database())
print(log_foldername+'/../input_data/{}_{}_input_data.txt'.format(tsp, rs))
tab_red = np.loadtxt(log_foldername+'/../input_data/{}_{}_input_data.txt'.format(tsp, rs))
ndims = tab_red.shape[0]
sigmas = np.abs(init_sig_mean + init_sig_var * np.random.randn(ndims, 1))
init_seed = sigmas
correlations = [] # = np.zeros((num_loops, ))
retrieved_loop = 0
# if (verbose):
# print("* training sigmas of gaussian kernels with cost '{}' and method '{}'".format(
# cost, method))
loop_cpt = 0
correlations = []
optim_options = {'disp': None, 'maxls': 50, 'iprint': -1, 'gtol': 1e-36, 'eps': 1e-8, 'maxiter': num_loops, 'ftol': 1e-36}
optim_bounds = [(1.0*f,1e5*f) for f in np.ones((ndims,))]
if logging:
pickle.dump({
'seed': init_seed,
'cost': cost,
'loss': loss,
'method': method,
'init_sig_mean': init_sig_mean,
'init_sig_var': init_sig_var,
'num_loops': num_loops,
'log_foldername': log_foldername,
'optim_options': {'options': optim_options, 'bounds': optim_bounds}
}, open(os.path.join(log_foldername, 'optim_config.pkl'), 'wb'))
def corr(x):
corr_sum = 0
for tsp in args['timbre_spaces']:
dissimil_mat_tsp = load.timbrespace_dismatrix(tsp, load.database())
tab_red = np.loadtxt(log_foldername+'/../input_data/{}_{}_input_data.txt'.format(tsp, rs))
# tab_red = np.loadtxt('input_data/{}_{}_input_data.txt'.format(tsp, rs))
ndims, ninstrus = tab_red.shape[0], tab_red.shape[1]
no_samples = ninstrus * (ninstrus - 1) / 2
idx_triu = np.triu_indices(dissimil_mat_tsp.shape[0], k=1)
target_v = dissimil_mat_tsp[idx_triu]
mean_target = np.mean(target_v)
std_target = np.std(target_v)
kernel = np.zeros((ninstrus, ninstrus))
for i in range(ninstrus):
for j in range(i + 1, ninstrus):
kernel[i, j] = -np.sum(
np.power(
np.divide(tab_red[:, i] - tab_red[:, j],
(x + np.finfo(float).eps)), 2))
kernel_v = kernel[idx_triu]
mean_kernel = np.mean(kernel_v)
std_kernel = np.std(kernel_v)
Jn = np.sum(np.multiply(kernel_v - mean_kernel, target_v - mean_target))
Jd = no_samples * std_target * std_kernel
corr_sum += Jn/Jd
return corr_sum
def grad_corr(x):
corr_sum = 0
for tsp_i, tsp in enumerate(args['timbre_spaces']):
dissimil_mat_tsp = load.timbrespace_dismatrix(tsp, load.database())
tab_red = np.loadtxt(log_foldername+'/../input_data/{}_{}_input_data.txt'.format(tsp, rs)) #np.loadtxt('input_data/{}_{}_input_data.txt'.format(tsp, rs))
# tab_red = np.loadtxt('input_data/{}_{}_input_data.txt'.format(tsp, rs))
ndims, ninstrus = tab_red.shape[0], tab_red.shape[1]
no_samples = ninstrus * (ninstrus - 1) / 2
idx_triu = np.triu_indices(dissimil_mat_tsp.shape[0], k=1)
target_v = dissimil_mat_tsp[idx_triu]
mean_target = np.mean(target_v)
std_target = np.std(target_v)
if tsp_i==0:
gradients = np.zeros((ndims, 1))
kernel = np.zeros((ninstrus, ninstrus))
dkernel = np.zeros((ninstrus, ninstrus, ndims))
for i in range(ninstrus):
for j in range(i + 1, ninstrus):
kernel[i, j] = -np.sum(
np.power(
np.divide(tab_red[:, i] - tab_red[:, j],
(x + np.finfo(float).eps)), 2))
dkernel[i, j, :] = 2 * np.power((tab_red[:, i] - tab_red[:, j]), 2) / (np.power(x, 3) + np.finfo(float).eps)
kernel_v = kernel[idx_triu]
mean_kernel = np.mean(kernel_v)
std_kernel = np.std(kernel_v)
Jn = np.sum(np.multiply(kernel_v - mean_kernel, target_v - mean_target))
Jd = no_samples * std_target * std_kernel
for k in range(ndims):
dkernel_k_v = dkernel[:, :, k][idx_triu]
dJn = np.sum(dkernel_k_v * (target_v - mean_target))
dJd = no_samples / no_samples * \
std_target / (std_kernel + np.finfo(float).eps) * \
np.sum(dkernel_k_v * (kernel_v - mean_kernel))
gradients[k] += (Jd * dJn - Jn * dJd) / (np.power(Jd,2) + np.finfo(float).eps)
return gradients
def print_corr(xk):
jns, jds = [], []
corr_sum = []
for tsp in args['timbre_spaces']:
dissimil_mat_tsp = load.timbrespace_dismatrix(tsp, load.database())
tab_red = np.loadtxt(log_foldername+'/../input_data/{}_{}_input_data.txt'.format(tsp, rs))
ndims, ninstrus = tab_red.shape[0], tab_red.shape[1]
no_samples = ninstrus * (ninstrus - 1) / 2
idx_triu = np.triu_indices(dissimil_mat_tsp.shape[0], k=1)
target_v = dissimil_mat_tsp[idx_triu]
mean_target = np.mean(target_v)
std_target = np.std(target_v)
kernel = np.zeros((ninstrus, ninstrus))
for i in range(ninstrus):
for j in range(i + 1, ninstrus):
kernel[i, j] = -np.sum(
np.power(
np.divide(tab_red[:, i] - tab_red[:, j],
(xk + np.finfo(float).eps)), 2))
kernel_v = kernel[idx_triu]
mean_kernel = np.mean(kernel_v)
std_kernel = np.std(kernel_v)
Jn = np.sum(np.multiply(kernel_v - mean_kernel, target_v - mean_target))
Jd = no_samples * std_target * std_kernel
corr_sum.append(Jn/Jd)
if not os.path.isfile(os.path.join(log_foldername, 'tmp.pkl')):
loop_cpt = 1
pickle.dump({'loop': loop_cpt, 'correlation': [np.mean(corr_sum)]}, open(os.path.join(log_foldername, 'tmp.pkl'), 'wb'))
correlations = [np.mean(corr_sum)]
pickle.dump({
'sigmas': xk,
'kernel': kernel,
'Jn': Jn,
'Jd': Jd,
'corr_sum': corr_sum,
'correlations': correlations,
}, open(os.path.join(log_foldername,
'optim_process_l={}.pkl'.format(loop_cpt)), 'wb'))
else:
last_loop = pickle.load(open(os.path.join(log_foldername,'tmp.pkl'), 'rb'))
loop_cpt = last_loop['loop'] + 1
correlations = last_loop['correlation']
correlations.append(np.mean(corr_sum))
monitoring_step = 50
if (loop_cpt % monitoring_step == 0):
corr_sum_str = ' '.join(['{:.2f}'.format(c) for c in corr_sum])
print(' |_ loop={} J={:.6f} ({})'.format(loop_cpt, np.mean(corr_sum), corr_sum_str))
pickle.dump({
'sigmas': xk,
'kernel': kernel,
'Jn': Jn,
'Jd': Jd,
'corr_sum': corr_sum,
'correlations': correlations,
}, open(os.path.join(log_foldername,
'optim_process_l={}.pkl'.format(loop_cpt)), 'wb'))
pickle.dump({'loop': loop_cpt, 'correlation': correlations, 'sigmas': xk}, open(os.path.join(log_foldername, 'tmp.pkl'), 'wb'))
res = minimize(corr, sigmas, args=(), method=method, jac=grad_corr, callback=print_corr, options=optim_options, bounds=optim_bounds)
last_loop = pickle.load(open(os.path.join(log_foldername,'tmp.pkl'), 'rb'))
sigmas_ = last_loop['sigmas']
return correlations, sigmas_
def compute_correlations_from_within_ts_tests():
args = {
'timbre_spaces': list(sorted(load.database().keys())),
'audio_representations': [
'auditory_spectrum', 'fourier_spectrum', 'auditory_strf',
'fourier_strf', 'auditory_spectrogram', 'fourier_spectrogram',
'auditory_mps', 'fourier_mps'
],
'res_foldername': './results_07-24-2018',
'log_foldername': './outs/ts_crossval_fixed',
}
corrs = []
for rs in args['audio_representations']:
print(rs)
corrs_rs = []
for tsp_i, tsp in enumerate(args['timbre_spaces']):
print(' ',tsp)
input_data = np.loadtxt(args['res_foldername']+'/{}_{}_input_data.txt'.format(tsp, rs))
target_data = np.loadtxt(args['res_foldername']+'/{}_{}_target_data.txt'.format(tsp, rs))
sigmas_ref = np.loadtxt(args['res_foldername']+'/{}_{}_sigmas.txt'.format(tsp, rs))
corrs_rs_tsp = []
all_corrc = []
all_sigmas = []
for tsp_j, tsp_2 in enumerate(args['timbre_spaces']):
if (tsp_i != tsp_j):
sigmas = np.loadtxt(args['res_foldername']+'/{}_{}_sigmas.txt'.format(tsp_2, rs))
all_sigmas.append(sigmas)
sigmas = np.mean(all_sigmas, axis=0)
for tsp_j, tsp_2 in enumerate(args['timbre_spaces']):
if (tsp_i != tsp_j):
ndims, ninstrus = input_data.shape[0], input_data.shape[1]
no_samples = ninstrus * (ninstrus - 1) / 2
idx_triu = np.triu_indices(target_data.shape[0], k=1)
target_v = target_data[idx_triu]
mean_target = np.mean(target_v)
std_target = np.std(target_v)
kernel = np.zeros((ninstrus, ninstrus))
for i in range(ninstrus):
for j in range(i + 1, ninstrus):
kernel[i, j] = -np.sum(
np.power(
np.divide(input_data[:, i] - input_data[:, j],
(sigmas + np.finfo(float).eps)), 2))
kernel_v = kernel[idx_triu]
mean_kernel = np.mean(kernel_v)
std_kernel = np.std(kernel_v)
Jn = np.sum(np.multiply(kernel_v - mean_kernel, target_v - mean_target))
Jd = no_samples * std_target * std_kernel
corrs_rs_tsp.append(Jn/Jd)
# for tsp_j, tsp_2 in enumerate(args['timbre_spaces']):
# if (tsp_i != tsp_j):
# sigmas = np.loadtxt(args['res_foldername']+'/{}_{}_sigmas.txt'.format(tsp_2, rs))
# ndims, ninstrus = input_data.shape[0], input_data.shape[1]
# no_samples = ninstrus * (ninstrus - 1) / 2
# idx_triu = np.triu_indices(target_data.shape[0], k=1)
# target_v = target_data[idx_triu]
# mean_target = np.mean(target_v)
# std_target = np.std(target_v)
# kernel = np.zeros((ninstrus, ninstrus))
# for i in range(ninstrus):
# for j in range(i + 1, ninstrus):
# kernel[i, j] = -np.sum(
# np.power(
# np.divide(input_data[:, i] - input_data[:, j],
# (sigmas + np.finfo(float).eps)), 2))
# kernel_v = kernel[idx_triu]
# mean_kernel = np.mean(kernel_v)
# std_kernel = np.std(kernel_v)
# Jn = np.sum(np.multiply(kernel_v - mean_kernel, target_v - mean_target))
# Jd = no_samples * std_target * std_kernel
# corrs_rs_tsp.append(Jn/Jd)
# print(' w/ {}: {:.5f} ({:.4f}, {:.4f})'.format(tsp_2, Jn/Jd, Jn, Jd))
# corrc = np.corrcoef(sigmas_ref, sigmas)[0,1]
# all_sigmas.append(sigmas)
# all_corrc.append(corrc)
# print(' --- {}', np.mean(all_corrc))
corrs_rs.append(np.mean(corrs_rs_tsp))
corrs.append(corrs_rs)
corrs_m = [np.mean(corrs_rs) for corrs_rs in corrs]
idx = sorted(range(len(args['audio_representations'])), key=lambda k: args['audio_representations'][k])
sorted_corrs = [corrs_m[k] for k in idx]
sorted_labels = [args['audio_representations'][k] for k in idx]
x = np.arange(len(corrs_m))
plt.figure(figsize=(12,8))
plt.plot(sorted_corrs, '-ok')
plt.xticks(x, sorted_labels)
plt.ylabel('correlation')
# plt.savefig(
# 'correlation_cross_ts.pdf',
# bbox_inches='tight')
plt.show()