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()