def _select_textures(args): params, input_files, tags = args ss = params['_select_frames']['ss'] pf = params['_select_frames']['pf'] selector = params['_select_frames']['selector'] n_frames = params['_select_frames']['n_frames'] select_subset = params['_select_frames']['select_subset'] out = [] #Here's the workaround to the h5 pickling issue. Just reload the storage =) if pf.has_h5_storage(): pf.reload_h5_storage() for f in input_files: features = ss.transform( pf.estimator_output[pf.get_single_track_idxs(f), :]) fs = select_frames.FrameSelector.get_selector(selector, params) selected = fs._select_frames(features, n_frames) if select_subset: selected = selected[:select_subset, :] selected = PredictedFeatures([f], [selected.shape[0]], selected, pf.label_idx_dict, [None], pf.get_track_label(f)) out.append(selected) if pf.has_h5_storage(): pf.h5file.close() return out
def get_textures(texture_hop, features_filename, output_file): features = dill.load(open(features_filename)) out = [] out_len = [] for f in features.track_filenames: out.append(linspace_textures(features.estimator_output[features.get_single_track_idxs(f),:], texture_hop)) out_len.append(out[-1].shape[0]) np.unique(out_len, return_counts=True) all_textures = PredictedFeatures(features.track_filenames, out_len, np.concatenate(out), features.label_idx_dict, [None] * len(features.track_filenames) , features.labels ) out = None all_textures.convert_storage_to_h5(output_file + '.h5') all_textures.h5file.close() dill.dump(all_textures, open(output_file, 'w'))
def get_identity_features(input_file, tags, params=None, output_file=None, **kwargs): predicted_features_input = params['identity_features']['predicted_features_input'] ld_text = open(params['general']['label_dict_file']).read() exec(ld_text) if predicted_features_input is not None: pfi = dill.load(open(predicted_features_input)) else: raise TypeError, 'identity_features.predicted_features_output must be set through the command line!' feats = pfi.estimator_output[pfi.get_single_track_idxs(input_file),:].T if params['identity_features']['deltas']: d = librosa.feature.delta(feats, order=1) else: d = np.empty((0,feats.shape[1])) if params['identity_features']['delta_deltas']: dd = librosa.feature.delta(feats, order=2) else: dd = np.empty((0,feats.shape[1])) feats = np.vstack((feats, d, dd)) pf = PredictedFeatures([input_file], [feats.shape[1]], feats.T, inv_dict(label_dict)) pf.labels = tags_to_matrix([tags], label_dict) pf.feature_filenames = [None] pfi.close_h5() if output_file is not None: dill.dump(pf, open(output_file, 'w')) pf = None return pf
def to_predicted_features(filelist, data_batches, estimator_output, label_dict_filename=None): from core.data.filelists import parse_filelist from core.data.predicted_features import PredictedFeatures X, Y = parse_filelist(filelist) if label_dict_filename is not None: ld_text = open(label_dict_filename).read() #this reads the dictionary into label_dict exec(ld_text) else: label_dict = None pf = PredictedFeatures(X, data_batches.track_nframes, estimator_output, label_dict, [None] * len(data_batches.track_nframes), Y) return pf
def select_frames(self, ipt): """ Selects frames using the instantiated selector. :param ipt: path to input PredictedFeatures pickle or PredictedFeatures instance. :returns: returns a new instance of PredictedFeatures containing only the selected features. :type ipt: str :rtype: PredictedFeatures """ import dill from core.data.predicted_features import PredictedFeatures if self.params is not None: normalize = self.params['frame_selector']['normalize'] n_frames = self.params['frame_selector']['n_frames'] else: normalize = True n_frames = 20 feats = ipt if isinstance(ipt, six.string_types): feats = dill.load(open(ipt)) assert isinstance( feats, PredictedFeatures ), "input features must be in PredictedFeatures format!" frames = self._select_frames(feats.estimator_output, n_frames, normalize) if self.params['frame_selector']['subset_size'] is not None: frames = frames[:self.params['frame_selector']['subset_size']] out = PredictedFeatures(feats.track_filenames, [frames.shape[0]], frames, feats.label_idx_dict, feats.feature_filenames, feats.labels) return out
def _select_frames(args): params, input_files, tags = args ss = params['_select_frames']['ss'] pf = dill.load(open(params['_select_frames']['pf_filename'])) out = [] # idxs = [ pf.get_single_track_idxs(f) for f in input_files ] # all_features = pf.estimator_output[np.concatenate(idxs),:] # print (all_features.shape) # all_features = ss.transform(all_features) # all_idxs = np.array(idxs) - idxs[0][0] # for i in xrange(len(input_files)): # features = all_features[all_idxs[i],:] # fs = select_frames.FrameSelector.get_selector( params['exp_gtzan_selframes']['frame_selector'], params ) # selected = fs._select_frames(features, params['frame_selector']['n_frames']) # selected = PredictedFeatures([input_files[i]], [selected.shape[0]], selected, pf.label_idx_dict, [None], pf.get_track_label(input_files[i])) # out.append(selected) for f in input_files: features = pf.estimator_output[pf.get_single_track_idxs(f),:] features = ss.transform(features) fs = select_frames.FrameSelector.get_selector( params['exp_gtzan_selframes']['frame_selector'], params ) selected = fs._select_frames(features, params['frame_selector']['n_frames']) if params['frame_selector']['subset_size'] is not None: selected = selected[:params['frame_selector']['subset_size']] selected = PredictedFeatures([f], [selected.shape[0]], selected, pf.label_idx_dict, [None], pf.get_track_label(f)) out.append(selected) if hasattr(pf, 'h5file'): pf.close_h5() return out
def main(fold_num, scratch_folder, extract_feats, centerk, ae_hs, ae_path, feature_set, dataset, extract_only, rp_target, rp_path_pattern): # Classification pipeline (frame selection) ######SETTINGS FOR GTZAN 3F ARTIST FILTER############ if dataset == 'gtzan_art3f': if feature_set == 'ae': folds_folder = 'gtzan_folds_filter_3f_strat_brava/' else: folds_folder = 'gtzan_folds_filter_3f_strat/' labels_file = folds_folder + 'gtzan_labels.txt' dataset = 'gtzan' texture_length = 216 texture_hop = 10 dict_file = folds_folder + 'gtzan_dict.py' n_folds = 3 ######SETTINGS FOR GTZAN 10F RANDOM############ if dataset == 'gtzan_10fs': if feature_set == 'ae': folds_folder = 'gtzan_folds_10fs_brava/' else: folds_folder = 'gtzan_folds_10fs/' labels_file = folds_folder + 'gtzan_labels.txt' dataset = 'gtzan' texture_length = 216 texture_hop = 10 dict_file = folds_folder + 'gtzan_dict.py' n_folds = 10 ######SETTINGS FOR LMD############ if dataset == 'lmd': if feature_set == 'ae': folds_folder = 'lmd_folds_brava/' else: folds_folder = 'lmd_folds/' labels_file = folds_folder + 'lmd_labels.txt' dataset = 'lmd' texture_length = 216 texture_hop = 10 dict_file = folds_folder + 'lmd_dict.py' n_folds = 3 ######SETTINGS FOR LMD 10s############ if dataset == 'lmd_10s': if feature_set == 'ae': folds_folder = 'lmd_folds_10s_brava/' else: folds_folder = 'lmd_folds_10s/' labels_file = folds_folder + 'lmd_labels.txt' dataset = 'lmd' texture_length = 216 texture_hop = 10 dict_file = folds_folder + 'lmd_dict.py' n_folds = 3 ######SETTINGS FOR HOMBURG############ if dataset == 'homburg': if feature_set == 'ae': folds_folder = 'homburg_folds_brava/' else: folds_folder = 'homburg_folds/' labels_file = folds_folder + 'homburg_labels.txt' dataset = 'homburg' texture_length = 216 texture_hop = 10 dict_file = folds_folder + 'homburg_dict.py' n_folds = 10 ######SETTINGS FOR ISMIR############ if dataset == 'ismir': if feature_set == 'ae': folds_folder = 'ismir_folds_brava/' else: folds_folder = 'ismir_folds/' labels_file = folds_folder + 'ismir_labels.txt' dataset = 'ismir' texture_length = 216 texture_hop = 10 dict_file = folds_folder + 'ismir_dict.py' n_folds = 1 ######SETTINGS FOR ISMIR 10s############ if dataset == 'ismir_10s': if feature_set == 'ae': folds_folder = 'ismir_folds_10s_brava/' else: folds_folder = 'ismir_folds_10s/' labels_file = folds_folder + 'ismir_labels.txt' dataset = 'ismir' texture_length = 216 texture_hop = 10 dict_file = folds_folder + 'ismir_dict.py' n_folds = 1 ######SETTINGS FOR EXBALLROOM############ # #scratch_folder = 'scratch11/' # folds_folder = 'exballroom_folds/' # labels_file = folds_folder + 'exballroom_labels.txt' # dataset = 'exballroom' # texture_length = 216 # texture_hop = 10 # dict_file = folds_folder + 'exballroom_dict.py' # n_folds = 10 print("Dataset Settings:") print("dataset: %s" % dataset) print('scratch_folder: %s' % scratch_folder) print('folds_folder: %s' % folds_folder) print('labels_file: %s' % labels_file) print('texture_length: %d' % texture_length) print('texture_hop: %d' % texture_hop) print('n_folds: %d' % n_folds) ################EXPERIMENT SETTINGS########################## features_filename = scratch_folder + 'features.dill' all_textures_filename = scratch_folder + 'all_features.dill' train_textures_filename = scratch_folder + 'train_textures.dill' test_textures_filename = scratch_folder + 'test_textures.dill' feature_extractor = feature_set task_extract = extract_feats #task_extract = False marsyas_fe_params = { 'gtzan_features': { 'n_mfcc': 20, 'n_fft': 2048, 'hop_length': 1024, 'target_sr': 44100, 'deltas': True, 'delta_deltas': True }, 'texture_avg_stdev_filter': { 'window_size': texture_length, 'mean': True, 'variance': True }, 'general': { 'label_dict_file': dict_file } } mel_fe_params = { 'stft_features': { 'n_fft': 2048, 'hop_length': 1024, 'target_sr': 44100, 'deltas': True, 'delta_deltas': True, 'mel_bins': 128, 'in_db': False }, 'texture_avg_stdev_filter': { 'window_size': texture_length, 'mean': True, 'variance': True }, 'general': { 'label_dict_file': dict_file } } rp_fe_params = { 'random_projection': { 'n_fft': 2048, 'hop_length': 1024, 'target_sr': 44100, 'deltas': True, 'delta_deltas': True, 'mel_bins': 128, 'non_linearity': None, 'in_db': False, 'projection_matrix': None }, 'texture_avg_stdev_filter': { 'window_size': texture_length, 'mean': True, 'variance': True }, 'general': { 'label_dict_file': dict_file } } ae_fe_params = { 'identity_features': { 'predicted_features_input': None, 'deltas': True, 'delta_deltas': True }, 'texture_avg_stdev_filter': { 'window_size': texture_length, 'mean': True, 'variance': True }, 'general': { 'label_dict_file': dict_file } } tsvm_params = { 'thundersvm': { #'gammas': ['auto', 0.1, 0.001, 0.0001], 'Cs': [10, 100, 1000], 'gammas': ['auto'], # 'Cs': [10], 'anova_percentiles': [None], 'no_anova': True, 'probability': False, 'kernel': 'rbf', 'hyperparameter_tuning': 'single_split', 'num_gpus': [0], }, 'general': { 'label_dict_file': dict_file } } tsvm_anova_params = { 'thundersvm': { #'gammas': ['auto', 0.1, 0.001, 0.0001], 'Cs': [10, 100, 1000], 'gammas': ['auto'], # 'Cs': [10], 'anova_percentiles': [25, 50, 75], 'no_anova': False, 'probability': False, 'kernel': 'rbf', 'hyperparameter_tuning': 'single_split', 'num_gpus': [0], }, 'general': { 'label_dict_file': dict_file } } knn_anova_params = { 'knn': { 'n_neighbors': [1, 3, 5, 7, 9], 'anova_percentiles': [20, 40, 60, 80], 'no_anova': False, 'num_workers': 8, 'grid_verbose': 10, }, 'general': { 'label_dict_file': dict_file }, 'single_split_gs': { 'groups_file': None } } knn_params = { 'knn': { 'n_neighbors': [1, 3, 5, 7, 9], 'anova_percentiles': [], 'no_anova': True, 'num_workers': 8, 'grid_verbose': 10, }, 'general': { 'label_dict_file': dict_file }, 'single_split_gs': { 'groups_file': None } } tester_params = {'general': {'label_dict_file': dict_file}} set_scratch_lock(scratch_folder) if task_extract: if centerk <= 0: centerk = False fe_params = eval(feature_extractor + '_fe_params') if feature_extractor == 'ae': features_file = ae_path + ('f%d_features_%d-feats.dill' % (fold_num, ae_hs)) print('Loading autoencoder features from %s...' % features_file) fe_params['identity_features'][ 'predicted_features_input'] = features_file if feature_extractor == 'rp': rpm_file = rp_path_pattern % (rp_target) print('Loading random projection matrix from %s...' % rpm_file) fe_params['random_projection']['projection_matrix'] = rpm_file extract_features(labels_file, fe_params, features_filename, centerk, feature_set=feature_extractor) get_textures(texture_hop, features_filename, all_textures_filename) if extract_only: release_scratch_lock(scratch_folder) exit(0) # exit(0) #skip this number of experiments skip = 0 skipped = 0 #for fold in (np.arange(n_folds) + 1): for fold in [fold_num]: print("@@@ FOLD %d" % fold) if skipped < skip: skipped += 1 print('skipping..') continue train_filelist = folds_folder + ('f%d_train.txt' % fold) test_filelist = folds_folder + ('f%d_test.txt' % fold) evaluate_filelist = folds_folder + ('f%d_evaluate.txt' % fold) ####################### TRAINING ########################## train_files, _ = parse_filelist(train_filelist) all_textures = dill.load(open(all_textures_filename)) train_data = [] train_len = [] train_filenames = [] train_labels = [] for f in train_files: train_data.append(all_textures.estimator_output[ all_textures.get_single_track_idxs(f), :]) train_len.append(train_data[-1].shape[0]) train_filenames.append(f) train_labels.append(all_textures.get_track_label(f)) train_textures = PredictedFeatures(train_filenames, train_len, np.concatenate(train_data), all_textures.label_idx_dict, [None] * len(train_filenames), train_labels) #WHEN ADDING A COMMAND LINE PARAMETER TO CHOOSE WHICH CLASSIFIERS TO USE, #LOOK AT MODEL_TESTER. ANOVA IS LOADED IF THE .ANOVA FILE EXISTS, REGARDLESS IF #THE MODEL HAS BEEN TRAINED WITH ANOVA IN THE PIPELINE OR NOT. TO GET AROUND #REMOVE THE .ANOVA FILE IN THE SAME DIRECTORY AS THE MODEL FILE BEFORE LOADING FOR PREDICTION. print('training SVM Model...') svm = ThunderSVM(params=tsvm_params) svm = svm.fit(train_textures, train_list_file=train_filelist) #dill.dump(svm, open(scratch_folder + 'trained_model.dill', 'w')) svm.named_steps['svm'].save_to_file(scratch_folder + 'trained_model.thundersvm') dill.dump(svm.named_steps['standardizer'], open(scratch_folder + 'trained_model.thundersvm.ss', 'w')) # print('training SVM (ANOVA) Model...') # svm_anova = ThunderSVM(params=tsvm_anova_params) # svm_anova = svm_anova.fit(train_textures, train_list_file=train_filelist) # svm_anova.named_steps['svm'].save_to_file(scratch_folder + 'trained_model_svm_anova.thundersvm') # dill.dump(svm_anova.named_steps['standardizer'], open(scratch_folder + 'trained_model_svm_anova.thundersvm.ss', 'w')) # dill.dump(svm_anova.named_steps['anova'], open(scratch_folder + 'trained_model_svm_anova.thundersvm.anova', 'w')) # print('training KNN (NO ANOVA) model...') # knn = KNN(params=knn_params) # knn = knn.fit(train_textures, train_list_file=train_filelist) # dill.dump(knn, open(scratch_folder + 'trained_model_knn.dill', 'w')) # print('training KNN (ANOVA) model...') # knn_anova = KNN(params=knn_anova_params) # knn_anova = knn_anova.fit(train_textures, train_list_file=train_filelist) # dill.dump(knn_anova, open(scratch_folder + 'trained_model_knn_anova.dill', 'w')) print('done training.') ############################TESTING########################## print('classifying frames...') mt = SklearnLike(params=tester_params) print('classifying with SVM...') predictions = mt.predict(scratch_folder + 'trained_model.thundersvm', all_textures, test_filelist, voting_model=False) mt.model = None dill.dump(predictions, open(scratch_folder + 'frame_predictions.dill', 'w')) # print('classifying with SVM (ANOVA)...') # predictions_svm_anova = mt.predict(scratch_folder+'trained_model_svm_anova.thundersvm', # all_textures, # test_filelist, # voting_model=False) # mt.model = None # dill.dump(predictions_svm_anova, open(scratch_folder + 'frame_predictions_svm_anova.dill', 'w')) # print('classifying with KNN (NO ANOVA)...') # predictions_knn = mt.predict(scratch_folder+'trained_model_knn.dill', # all_textures, # test_filelist, # voting_model=False) # dill.dump(predictions_knn, open(scratch_folder + 'frame_predictions_knn.dill', 'w')) # print('classifying with KNN (ANOVA)...') # predictions_knn_anova = mt.predict(scratch_folder+'trained_model_knn_anova.dill', # all_textures, # test_filelist, # voting_model=False) # dill.dump(predictions_knn_anova, open(scratch_folder + 'frame_predictions_knn_anova.dill', 'w')) print('done classifying frames...') all_textures.close_h5() ###########################EVALUATING########################### voter = MaxVoting(params=None) print('max voting & evaluating SVM results...') final_predictions = voter.vote(predictions, output_fmt='text') with open(scratch_folder + 'final_predictions.txt', 'w') as f: f.write(final_predictions) eval_classification([ 'script', scratch_folder + 'final_predictions.txt', evaluate_filelist ]) # print('max voting & evaluating SVM (ANOVA) results...') # final_predictions_svm_anova = voter.vote(predictions_svm_anova, output_fmt='text') # with open(scratch_folder + 'final_predictions_svm_anova.txt', 'w') as f: # f.write(final_predictions_svm_anova) # eval_classification(['script',scratch_folder + 'final_predictions_svm_anova.txt', evaluate_filelist]) # print('max voting & evaluating KNN (NO ANOVA) results...') # final_predictions = voter.vote(predictions_knn, output_fmt='text') # with open(scratch_folder + 'final_predictions_knn.txt', 'w') as f: # f.write(final_predictions) # eval_classification(['script',scratch_folder + 'final_predictions_knn.txt', evaluate_filelist]) # print('max voting & evaluating KNN (ANOVA) results...') # final_predictions = voter.vote(predictions_knn_anova, output_fmt='text') # with open(scratch_folder + 'final_predictions_knn_anova.txt', 'w') as f: # f.write(final_predictions) # eval_classification(['script',scratch_folder + 'final_predictions_knn_anova.txt', evaluate_filelist]) print('done!') os.system('nvidia-smi') os.system('free -h') release_scratch_lock(scratch_folder)