def download(self, force_download=False):
zenodo_url = "https://zenodo.org/record/2552860/files"
zenodo_files = [
'FSDKaggle2018.audio_test.zip', 'FSDKaggle2018.audio_train.zip',
'FSDKaggle2018.doc.zip', 'FSDKaggle2018.meta.zip'
]
super().download(zenodo_url, zenodo_files, force_download)
mkdir_if_not_exists(self.audio_path)
os.rename(
os.path.join(self.dataset_path, 'FSDKaggle2018.audio_train'),
os.path.join(self.audio_path, 'train'),
)
os.rename(
os.path.join(self.dataset_path, 'FSDKaggle2018.audio_test'),
os.path.join(self.audio_path, 'test'),
)
os.rename(
os.path.join(self.dataset_path, 'FSDKaggle2018.meta'),
os.path.join(self.dataset_path, 'meta'),
)
os.rename(
os.path.join(self.dataset_path, 'FSDKaggle2018.doc'),
os.path.join(self.dataset_path, 'doc'),
)
self.set_as_downloaded()
def test_check_if_extracted():
dataset_path = "./tests/data"
dataset = Dataset(dataset_path)
path = "./tests/data/features/FeatureExtractor/original"
mkdir_if_not_exists(path, parents=True)
feature_extractor = FeatureExtractor()
json_features = os.path.join(path, "parameters.json")
_clean(json_features)
feature_extractor.set_as_extracted(path)
assert feature_extractor.check_if_extracted(dataset)
def test_move_all_files_to_parent():
parent = "./new_parent"
mkdir_if_not_exists("./new_parent/new_child", parents=True)
mkdir_if_not_exists("./new_parent/new_child2")
move_all_files_to_parent("./", "new_parent")
assert os.path.exists("./new_child")
assert os.path.exists("./new_child2")
_clean("./new_child")
_clean("./new_child2")
_clean("./new_parent")
def test_move_all_files_to():
parent = "./new_parent"
mkdir_if_not_exists("./new_parent/new_child", parents=True)
mkdir_if_not_exists("./new_parent/new_child2")
dest = "./dest"
move_all_files_to("./new_parent", dest)
assert os.path.exists("./dest/new_child")
assert os.path.exists("./dest/new_child2")
assert not os.path.exists("./new_parent/new_child")
assert not os.path.exists("./new_parent/new_child2")
_clean("./dest")
_clean("./new_parent")
def test_mkdir_if_not_exists():
folder = "./new_folder"
_clean(folder)
mkdir_if_not_exists(folder)
assert os.path.isdir(folder)
_clean(folder)
folder = "./new_parent/new_folder"
mkdir_if_not_exists(folder, parents=True)
assert os.path.isdir("./new_parent")
assert os.path.isdir(folder)
_clean(folder)
_clean("./new_parent")
def test_duplicate_folder_structure():
folder1 = "./new_parent/new_folder1"
folder2 = "./new_parent/new_folder2"
mkdir_if_not_exists(folder1, parents=True)
mkdir_if_not_exists(folder2)
folder_destination = "./test_dest"
_clean(folder_destination)
duplicate_folder_structure("./new_parent", folder_destination)
assert os.path.isdir(folder_destination)
assert os.path.isdir(os.path.join(folder_destination, "new_folder1"))
assert os.path.isdir(os.path.join(folder_destination, "new_folder2"))
_clean(folder_destination)
_clean("./new_parent")
def extract(self, dataset):
""" Extracts features for each file in dataset.
Call calculate() for each file in dataset and save the
result into the features path.
Parameters
----------
dataset : Dataset
Instance of the dataset.
"""
features_path = self.get_features_path(dataset)
mkdir_if_not_exists(features_path, parents=True)
if not dataset.check_sampling_rate(self.sr):
print('Changing sampling rate ...')
dataset.change_sampling_rate(self.sr)
print('Done!')
# Define path to audio and features folders
audio_path, subfolders = dataset.get_audio_paths(self.sr)
# Duplicate folder structure of audio in features folder
duplicate_folder_structure(audio_path, features_path)
for audio_folder in subfolders:
subfolder_name = os.path.basename(audio_folder)
features_path_sub = os.path.join(features_path, subfolder_name)
if not self.check_if_extracted_path(features_path_sub):
# Navigate in the structure of audio folder and extract
# features of the each wav file
for path_audio in progressbar(list_wav_files(audio_folder)):
features_array = self.calculate(path_audio)
path_to_features_file = path_audio.replace(
audio_path, features_path)
path_to_features_file = path_to_features_file.replace(
'wav', 'npy')
np.save(path_to_features_file, features_array)
# Save parameters.json for future checking
self.set_as_extracted(features_path_sub)
def download(self, force_download=False):
zenodo_url = "https://zenodo.org/record/3338727/files/"
zenodo_files = [
'audio_train.zip', 'audio_validate.zip', 'audio_test.zip',
'annotations_train.zip', 'annotations_validate.zip',
'annotations_test.zip', 'README'
]
super().download(zenodo_url, zenodo_files, force_download)
mkdir_if_not_exists(self.audio_path)
mkdir_if_not_exists(self.annotations_path)
for fold in self.fold_list:
os.rename(os.path.join(self.dataset_path, 'audio_%s' % fold),
os.path.join(self.audio_path, fold))
os.rename(os.path.join(self.dataset_path, 'annotations_%s' % fold),
os.path.join(self.annotations_path, fold))
# Convert .flac to .wav
self.convert_to_wav()
self.set_as_downloaded()
def main():
# Parse arguments
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument(
'-d',
'--dataset',
type=str,
help='dataset name (e.g. UrbanSound8k, ESC50, URBAN_SED, SONYC_UST)',
default='UrbanSound8k')
parser.add_argument(
'-f',
'--features',
type=str,
help='features name (e.g. Spectrogram, MelSpectrogram, Openl3)',
default='MelSpectrogram')
parser.add_argument('-p',
'--path',
type=str,
help='path to the parameters.json file',
default='../')
parser.add_argument(
'-m',
'--model',
type=str,
help='model name (e.g. MLP, SB_CNN, SB_CNN_SED, A_CRNN, VGGish)',
default='SB_CNN')
parser.add_argument('-fold',
'--fold_name',
type=str,
help='fold name',
default='fold1')
parser.add_argument('-s',
'--models_path',
type=str,
help='path to save the trained model',
default='../trained_models')
parser.add_argument('--aug', dest='augmentation', action='store_true')
parser.add_argument('--no-aug', dest='augmentation', action='store_false')
parser.set_defaults(augmentation=False)
args = parser.parse_args()
print(__doc__)
if args.dataset not in get_available_datasets():
raise AttributeError('Dataset not available')
if args.features not in get_available_features():
raise AttributeError('Features not available')
if args.model not in get_available_models():
raise AttributeError('Model not available')
# Get parameters
parameters_file = os.path.join(args.path, 'parameters.json')
params = load_json(parameters_file)
params_dataset = params['datasets'][args.dataset]
params_features = params['features']
params_model = params['models'][args.model]
# Get and init dataset class
dataset_class = get_available_datasets()[args.dataset]
dataset_path = os.path.join(args.path, params_dataset['dataset_path'])
dataset = dataset_class(dataset_path)
if args.fold_name not in dataset.fold_list:
raise AttributeError('Fold not available')
# Data augmentation
if args.augmentation:
# Define the augmentations
augmentations = params['data_augmentations']
# Initialize AugmentedDataset
dataset = AugmentedDataset(dataset, params['features']['sr'],
augmentations)
# Process all files
print('Doing data augmentation ...')
dataset.process()
print('Done!')
# Get and init feature class
features_class = get_available_features()[args.features]
features = features_class(
sequence_time=params_features['sequence_time'],
sequence_hop_time=params_features['sequence_hop_time'],
audio_win=params_features['audio_win'],
audio_hop=params_features['audio_hop'],
sr=params_features['sr'],
**params_features[args.features])
print('Features shape: ', features.get_shape())
# Check if features were extracted
if not features.check_if_extracted(dataset):
print('Extracting features ...')
features.extract(dataset)
print('Done!')
use_validate_set = True
if args.dataset in ['TUTSoundEvents2017', 'ESC50', 'ESC10']:
# When have less data, don't use validation set.
use_validate_set = False
folds_train, folds_val, _ = evaluation_setup(
args.fold_name,
dataset.fold_list,
params_dataset['evaluation_mode'],
use_validate_set=use_validate_set)
data_gen_train = DataGenerator(dataset,
features,
folds=folds_train,
batch_size=params['train']['batch_size'],
shuffle=True,
train=True,
scaler=None)
scaler = Scaler(normalizer=params_model['normalizer'])
print('Fitting scaler ...')
scaler.fit(data_gen_train)
print('Done!')
# Pass scaler to data_gen_train to be used when data
# loading
data_gen_train.set_scaler(scaler)
data_gen_val = DataGenerator(dataset,
features,
folds=folds_val,
batch_size=params['train']['batch_size'],
shuffle=False,
train=False,
scaler=scaler)
# Define model
features_shape = features.get_shape()
n_frames_cnn = features_shape[1]
n_freq_cnn = features_shape[2]
n_classes = len(dataset.label_list)
model_class = get_available_models()[args.model]
metrics = ['classification']
if args.dataset in sed_datasets:
metrics = ['sed']
if args.dataset in tagging_datasets:
metrics = ['tagging']
model_container = model_class(model=None,
model_path=None,
n_classes=n_classes,
n_frames_cnn=n_frames_cnn,
n_freq_cnn=n_freq_cnn,
metrics=metrics,
**params_model['model_arguments'])
model_container.model.summary()
# Set paths
model_folder = os.path.join(args.models_path, args.model, args.dataset)
exp_folder = os.path.join(model_folder, args.fold_name)
mkdir_if_not_exists(exp_folder, parents=True)
# Save model json and scaler
model_container.save_model_json(model_folder)
save_pickle(scaler, os.path.join(exp_folder, 'scaler.pickle'))
# data_train = data_gen_train.get_data()
# data_val = data_gen_val.get_data()
# Train model
model_container.train(
data_gen_train,
data_gen_val,
# data_train, data_val,
label_list=dataset.label_list,
weights_path=exp_folder,
**params['train'],
sequence_time_sec=params_features['sequence_hop_time'])
def main():
# Parse arguments
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter
)
parser.add_argument(
'-od', '--origin_dataset', type=str,
help='dataset name (e.g. UrbanSound8k, ESC50, URBAN_SED, SONYC_UST)',
default='UrbanSound8k'
)
parser.add_argument(
'-ofold', '--origin_fold_name', type=str,
help='origin fold name',
default='fold1')
parser.add_argument(
'-d', '--dataset', type=str,
help='dataset name (e.g. UrbanSound8k, ESC50, URBAN_SED, SONYC_UST)',
default='ESC50'
)
parser.add_argument(
'-fold', '--fold_name', type=str,
help='destination fold name',
default='fold1')
parser.add_argument(
'-f', '--features', type=str,
help='features name (e.g. Spectrogram, MelSpectrogram, Openl3)',
default='MelSpectrogram'
)
parser.add_argument(
'-p', '--path', type=str,
help='path to the parameters.json file',
default='../'
)
parser.add_argument(
'-m', '--model', type=str,
help='model name (e.g. MLP, SB_CNN, SB_CNN_SED, A_CRNN, VGGish)',
default='SB_CNN')
parser.add_argument(
'-s', '--models_path', type=str,
help='path to save the trained model',
default='../trained_models'
)
args = parser.parse_args()
print(__doc__)
if args.dataset not in get_available_datasets():
raise AttributeError('Dataset not available')
if args.features not in get_available_features():
raise AttributeError('Features not available')
if args.model not in get_available_models():
raise AttributeError('Model not available')
# Get parameters
parameters_file = os.path.join(args.path, 'parameters.json')
params = load_json(parameters_file)
params_dataset = params['datasets'][args.dataset]
params_features = params['features']
params_model = params['models'][args.model]
# Load origin model
model_path_origin = os.path.join(args.models_path, args.model,
args.origin_dataset)
model_class = get_available_models()[args.model]
metrics = ['accuracy']
if args.dataset in sed_datasets:
metrics = ['sed']
model_container = model_class(
model=None, model_path=model_path_origin,
metrics=metrics
)
model_container.load_model_weights(
os.path.join(model_path_origin, args.origin_fold_name))
kwargs = {}
if args.dataset in sed_datasets:
kwargs = {'sequence_hop_time': params_features['sequence_hop_time']}
# Get and init dataset class
dataset_class = get_available_datasets()[args.dataset]
dataset_path = os.path.join(args.path, params_dataset['dataset_path'])
dataset = dataset_class(dataset_path, **kwargs)
if args.fold_name not in dataset.fold_list:
raise AttributeError('Fold not available')
# Get and init feature class
features_class = get_available_features()[args.features]
features = features_class(
sequence_time=params_features['sequence_time'],
sequence_hop_time=params_features['sequence_hop_time'],
audio_win=params_features['audio_win'],
audio_hop=params_features['audio_hop'],
sr=params_features['sr'], **params_features[args.features]
)
print('Features shape: ', features.get_shape())
# Check if features were extracted
if not features.check_if_extracted(dataset):
print('Extracting features ...')
features.extract(dataset)
print('Done!')
use_validate_set = True
if args.dataset in ['TUTSoundEvents2017', 'ESC50', 'ESC10']:
# When have less data, don't use validation set.
use_validate_set = False
folds_train, folds_val, _ = evaluation_setup(
args.fold_name, dataset.fold_list,
params_dataset['evaluation_mode'],
use_validate_set=use_validate_set
)
data_gen_train = DataGenerator(
dataset, features, folds=folds_train,
batch_size=params['train']['batch_size'],
shuffle=True, train=True, scaler=None
)
scaler = Scaler(normalizer=params_model['normalizer'])
print('Fitting features ...')
scaler.fit(data_gen_train)
print('Done!')
data_gen_train.set_scaler(scaler)
data_gen_val = DataGenerator(
dataset, features, folds=folds_val,
batch_size=params['train']['batch_size'],
shuffle=False, train=False, scaler=scaler
)
# Fine-tune model
n_classes = len(dataset.label_list)
layer_where_to_cut = -2
model_container.fine_tuning(layer_where_to_cut,
new_number_of_classes=n_classes,
new_activation='sigmoid',
freeze_source_model=True)
model_container.model.summary()
# Set paths
model_folder = os.path.join(
args.models_path, args.model,
args.origin_dataset+'_ft_'+args.dataset)
exp_folder = os.path.join(model_folder, args.fold_name)
mkdir_if_not_exists(exp_folder, parents=True)
# Save model json and scaler
model_container.save_model_json(model_folder)
save_pickle(scaler, os.path.join(exp_folder, 'scaler.pickle'))
# Train model
model_container.train(
data_gen_train, data_gen_val,
label_list=dataset.label_list,
weights_path=exp_folder,
sequence_time_sec=params_features['sequence_hop_time'],
**params['train'])
def start_training(status, fold_ix, normalizer, model_path, epochs,
early_stopping, optimizer_ix, learning_rate, batch_size,
considered_improvement, n_clicks_train, dataset_ix):
global data_generator_train
global data_generator_val
if status == 'TRAINING':
if fold_ix is None:
return [True, 'Please select a Fold', 'danger', ""]
if optimizer_ix is None:
return [True, 'Please select an Optimizer', 'danger', ""]
dataset_name = options_datasets[dataset_ix]['label']
fold_name = dataset.fold_list[fold_ix]
params_dataset = params['datasets'][dataset_name]
optimizer = options_optimizers[optimizer_ix]['label']
use_validate_set = True
if dataset_name in ['TUTSoundEvents2017', 'ESC50', 'ESC10']:
# When have less data, don't use validation set.
use_validate_set = False
folds_train, folds_val, _ = evaluation_setup(
fold_name,
dataset.fold_list,
params_dataset['evaluation_mode'],
use_validate_set=use_validate_set)
data_generator_train = DataGenerator(
dataset,
feature_extractor,
folds=folds_train,
batch_size=params['train']['batch_size'],
shuffle=True,
train=True,
scaler=None)
scaler = Scaler(normalizer=normalizer)
print('Fitting scaler ...')
scaler.fit(data_generator_train)
print('Done!')
# Pass scaler to data_gen_train to be used when data
# loading
data_generator_train.set_scaler(scaler)
data_generator_val = DataGenerator(dataset,
feature_extractor,
folds=folds_val,
batch_size=batch_size,
shuffle=False,
train=False,
scaler=scaler)
exp_folder_fold = conv_path(os.path.join(model_path, fold_name))
mkdir_if_not_exists(exp_folder_fold, parents=True)
scaler_path = os.path.join(exp_folder_fold, 'scaler.pickle')
save_pickle(scaler, scaler_path)
train_arguments = {
'epochs': epochs,
'early_stopping': early_stopping,
'optimizer': optimizer,
'learning_rate': learning_rate,
'batch_size': batch_size,
'considered_improvement': considered_improvement
}
with graph.as_default():
model_container.train(data_generator_train,
data_generator_val,
weights_path=exp_folder_fold,
label_list=dataset.label_list,
**train_arguments)
model_container.load_model_weights(exp_folder_fold)
return [True, "Model trained", 'success', 'True']
else:
raise dash.exceptions.PreventUpdate
def create_model(n_clicks_create_model, n_clicks_load_model, model_ix,
feature_ix, dataset_ix, model_parameters, sequence_time,
sequence_hop_time, audio_hop, audio_win, sr,
specific_parameters, dataset_path, audio_folder,
features_folder, model_path):
global model_container
global feature_extractor
global dataset
ctx = dash.callback_context
if (n_clicks_create_model is None) & (n_clicks_load_model is None):
return [False, "", 'success', '']
else:
button_id = ctx.triggered[0]['prop_id'].split('.')[0]
if (button_id == 'create_model') | (button_id == 'load_model'):
if model_ix is None:
return [True, 'Please select a Model', 'danger', '']
if feature_ix is None:
return [True, 'Please select a Feature extractor', 'danger', '']
if dataset_ix is None:
return [True, 'Please select a Dataset', 'danger', '']
model_name = options_models[model_ix]['label']
feature_name = options_features[feature_ix]['label']
dataset_name = options_datasets[dataset_ix]['label']
feature_extractor_class = get_available_features()[feature_name]
specific_parameters = ast.literal_eval(specific_parameters)
feature_extractor = feature_extractor_class(
sequence_time=sequence_time,
sequence_hop_time=sequence_hop_time,
audio_win=audio_win,
audio_hop=audio_hop,
sr=sr,
**specific_parameters)
features_shape = feature_extractor.get_shape()
n_frames_cnn = features_shape[1]
n_freq_cnn = features_shape[2]
# get dataset class
dataset_class = get_available_datasets()[dataset_name]
# init data_generator
kwargs = {}
if dataset_name == 'URBAN_SED':
kwargs = {'sequence_hop_time': sequence_hop_time}
dataset = dataset_class(dataset_path, **kwargs)
n_classes = len(dataset.label_list)
model_class = get_available_models()[model_name]
model_parameters = ast.literal_eval(model_parameters)
if (button_id == 'create_model'):
with graph.as_default():
model_container = model_class(model=None,
model_path=None,
n_classes=n_classes,
n_frames_cnn=n_frames_cnn,
n_freq_cnn=n_freq_cnn,
**model_parameters)
model_container.model.summary()
if model_name == 'VGGish':
model_container.load_pretrained_model_weights()
model_container.fine_tuning(
-1,
new_number_of_classes=n_classes,
new_activation='softmax',
freeze_source_model=True)
stringlist = []
model_container.model.summary(
print_fn=lambda x: stringlist.append(x))
summary = "\n".join(stringlist)
mkdir_if_not_exists(conv_path(os.path.dirname(model_path)))
mkdir_if_not_exists(conv_path(model_path))
model_container.save_model_json(conv_path(model_path))
return [True, 'Model created', 'success', summary]
if (button_id == 'load_model'):
with graph.as_default():
model_container = model_class(model=None,
model_path=conv_path(model_path))
model_container.model.summary()
stringlist = []
model_container.model.summary(
print_fn=lambda x: stringlist.append(x))
summary = "\n".join(stringlist)
return [True, 'Model loaded', 'success', summary]
# model_container.save_model_weights(model_path)
return [False, "", 'success', '']
X_pca = np.zeros((1, 4))
X = np.zeros((1, 128, 64))
Y = np.zeros((1, 10))
file_names = []
graph = get_default_graph()
# VIS TAB
def conv_path(file_or_folder):
return os.path.join(os.path.dirname(__file__), file_or_folder)
mkdir_if_not_exists(conv_path('models'))
@app.callback(
[Output('plot_mel', 'figure'),
Output('audio-player', 'overrideProps')],
[Input('plot2D', 'selectedData')],
[State('x_select', 'value'),
State('y_select', 'value')])
def click_on_plot2d(clickData, x_select, y_select):
if clickData is None:
figure_mel = generate_figure_mel(X[0])
return [figure_mel, {'autoPlay': False, 'src': ''}]
else:
point = np.array(
[clickData['points'][0]['x'], clickData['points'][0]['y']])