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)