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 
Ejemplo n.º 3
0
def nonopt_correlations():
    corr_results = {}
    for i, tsp in enumerate(timbrespace_db.keys()):
        print('Processing', tsp)
        corr_results[tsp] = {}
        target_data = load.timbrespace_dismatrix(tsp, timbrespace_db)
        for rs in sorted(representations):
            aud_repres = load.timbrespace_features(
                tsp,
                representations=[rs],
                window=None,
                timbrespace_db=None,
                verbose=False)[rs]
            tab_red = []
            rs_type = rs.split('_')[-1]
            if rs_type == 'strf':
                n_components = 1
                for i in range(len(aud_repres)):
                    # print('PCA on sound %02i' % (i + 1))
                    strf_reduced = pca.pca(
                        np.absolute(aud_repres[i]),
                        aud_repres[i].shape[1],
                        n_components=n_components).flatten()
                    tab_red.append(strf_reduced / np.max(strf_reduced))
                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])
                # 128 x nb sounds (time or freq?)
                tab_red = np.transpose(np.asarray(tab_red))
            input_data = tab_red / np.mean(np.std(tab_red, axis=0))

            # plt.plot(input_data)
            # plt.show()
            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(input_data[:, i] - input_data[:, j], 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 - 1) * std_target * std_kernel
            corr_results[tsp][rs] = Jn / Jd
            print('  {} : {}'.format(rs, Jn / Jd))
    pickle.dump(corr_results, open('correlations_results.pkl', 'wb'))
Ejemplo n.º 4
0
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(
        tsp,
        representations=[rs],
        window=None,
        timbrespace_db=None,
        verbose=True)[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(
                np.absolute(aud_repres[i]),
                aud_repres[i].shape[1],
                n_components=n_components)
            strf_reduced = strf_reduced.flatten()
            tab_red.append(strf_reduced)
            # tab_red.append(strf_reduced / np.max(strf_reduced))
        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])
        # 128 x nb sounds (time or freq?)
        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,
    }, open(os.path.join(rslog_foldername, 'dataset.pkl'), 'wb'))
    print('  data dimension:', tab_red.shape)
    print('* normalizing')
    tab_red = tab_red / np.max(np.max(np.abs(tab_red), axis=0))
    # plt.plot(tab_red)
    # plt.show()
    # optimization
    correlations = training.kernel_optim(tab_red, dissimil_mat, **optim_args)
Ejemplo n.º 5
0
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'])
Ejemplo n.º 6
0
def resume_all(resumefn='./outs/'):
    for i, tsp in enumerate(sorted(timbrespace_db.keys())):
        print('Processing', tsp)
        dissimil_mat = load.timbrespace_dismatrix(tsp, timbrespace_db)
        for rs in representations:
            # for el in dir_names:
            #     if el[1].split('-')[0] == tsp.lower() and el[1].split(
            #             '-')[1] == rs:
            rslog_foldername = './outs/' + tsp.lower() + '/' + rs
            if os.path.isdir(rslog_foldername):
                # retrieve_foldername = os.path.join(el[0], el[1])
                training.resume_kernel_optim(
                    rslog_foldername,
                    rslog_foldername,
                    num_loops=100000,
                    logging=True)
            else:
                subprocess.call(['mkdir', '-p', rslog_foldername])
                run_once(tsp, rs, rslog_foldername)
    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
Ejemplo n.º 8
0
def resume_some(tsps=None, reps=None):
    tspaces = tsp if tsps != None else timbrespace_db.keys()
    some_reps = reps if reps != None else representations
    for i, tsp in enumerate(sorted(tspaces)):
        print('Processing', tsp)
        dissimil_mat = load.timbrespace_dismatrix(tsp, timbrespace_db)
        for rs in some_reps:
            rslog_foldername = './outs_all/' + tsp.lower() + '/' + rs
            if os.path.isdir(rslog_foldername):
                resume = {}
                for root, dirs, files in os.walk(rslog_foldername):
                    loop_id = []
                    for name in files:
                        if name.split('.')[-1] == 'pkl' and 'optim_process' in name.split('.')[0]:
                            loop_id.append(int(name.split('.')[0].split('=')[-1]))
                
                optim_process = pickle.load(open(os.path.join(retrieve_foldername,'optim_process_l={}.pkl'.format(retrieved_loop)), 'rb'))
                optim_config = pickle.load(open(os.path.join(retrieve_foldername,'optim_config.pkl'), 'rb'))
                dataset = pickle.load(open(os.path.join(retrieve_foldername,'dataset.pkl'), 'rb'))

                input_data = dataset['data_proj']
                target_data = dataset['dissimilarities']

                resume['retrieved_loop'] = np.max(loop_id)
                resume['init_seed'] = optim_config['seed']

                if verbose:
                    print("* resuming with '{}' of size {}".format(retrieve_foldername.split('/')[-1], input_data.shape))

                init_seed = optim_config['seed']
                cost = optim_config['args']['cost']
                init_sig_mean = optim_config['args']['init_sig_mean']
                init_sig_var = optim_config['args']['init_sig_var']
                training.resume_kernel_optim(
                    rslog_foldername,
                    rslog_foldername,
                    num_loops=100000,
                    logging=True)
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])))
Ejemplo n.º 11
0
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'))
Ejemplo n.º 13
0
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_