def fileRegression(inputFile, model_name, model_type):
# Load classifier:
if not os.path.isfile(inputFile):
print("fileClassification: wav file not found!")
return (-1, -1, -1)
regression_models = glob.glob(model_name + "_*")
regression_models2 = []
for r in regression_models:
if r[-5::] != "MEANS":
regression_models2.append(r)
regression_models = regression_models2
regression_names = []
for r in regression_models:
regression_names.append(r[r.rfind("_")+1::])
# FEATURE EXTRACTION
# LOAD ONLY THE FIRST MODEL (for mt_win, etc)
if model_type == 'svm' or model_type == "svm_rbf" or \
model_type == 'randomforest':
[_, _, _, mt_win, mt_step, st_win, st_step, compute_beat] = \
load_model(regression_models[0], True)
# read audio file and convert to mono
[Fs, x] = audioBasicIO.read_audio_file(inputFile)
x = audioBasicIO.stereo_to_mono(x)
# feature extraction:
[mt_features, s, _] = aF.mid_feature_extraction(x, Fs,
mt_win * Fs,
mt_step * Fs,
round(Fs * st_win),
round(Fs * st_step))
# long term averaging of mid-term statistics
mt_features = mt_features.mean(axis=1)
if compute_beat:
[beat, beatConf] = aF.beat_extraction(s, st_step)
mt_features = np.append(mt_features, beat)
mt_features = np.append(mt_features, beatConf)
# REGRESSION
R = []
for ir, r in enumerate(regression_models):
if not os.path.isfile(r):
print("fileClassification: input model_name not found!")
return (-1, -1, -1)
if model_type == 'svm' or model_type == "svm_rbf" \
or model_type == 'randomforest':
[model, MEAN, STD, mt_win, mt_step, st_win,
st_step, compute_beat] = load_model(r, True)
curFV = (mt_features - MEAN) / STD # normalization
R.append(regressionWrapper(model, model_type, curFV)) # classification
return R, regression_names
def directory_feature_extraction_no_avg(folder_path, mid_window, mid_step,
short_window, short_step):
"""
This function extracts the mid-term features of the WAVE
files of a particular folder without averaging each file.
ARGUMENTS:
- dirName: the path of the WAVE directory
- mt_win, mt_step: mid-term window and step (in seconds)
- st_win, st_step: short-term window and step (in seconds)
RETURNS:
- X: A feature matrix
- Y: A matrix of file labels
- filenames:
"""
wav_file_list = []
signal_idx = np.array([])
mid_features = np.array([])
types = ('*.wav', '*.aif', '*.aiff', '*.ogg')
for files in types:
wav_file_list.extend(glob.glob(os.path.join(folder_path, files)))
wav_file_list = sorted(wav_file_list)
for i, file_path in enumerate(wav_file_list):
sampling_rate, signal = audioBasicIO.read_audio_file(file_path)
if sampling_rate == 0:
continue
signal = audioBasicIO.stereo_to_mono(signal)
mid_feature_vector, _, _ = \
mid_feature_extraction(signal, sampling_rate,
round(mid_window * sampling_rate),
round(mid_step * sampling_rate),
round(sampling_rate * short_window),
round(sampling_rate * short_step))
mid_feature_vector = np.transpose(mid_feature_vector)
if len(mid_features) == 0: # append feature vector
mid_features = mid_feature_vector
signal_idx = np.zeros((mid_feature_vector.shape[0], ))
else:
mid_features = np.vstack((mid_features, mid_feature_vector))
signal_idx = np.append(signal_idx, i *
np.ones((mid_feature_vector.shape[0], )))
return mid_features, signal_idx, wav_file_list
def mid_feature_extraction_to_file(file_path, mid_window, mid_step,
short_window, short_step, output_file,
store_short_features=False, store_csv=False,
plot=False):
"""
This function is used as a wrapper to:
a) read the content of a WAV file
b) perform mid-term feature extraction on that signal
c) write the mid-term feature sequences to a np file
"""
sampling_rate, signal = audioBasicIO.read_audio_file(file_path)
signal = audioBasicIO.stereo_to_mono(signal)
if store_short_features:
mid_features, short_features, _ = \
mid_feature_extraction(signal, sampling_rate,
round(sampling_rate * mid_window),
round(sampling_rate * mid_step),
round(sampling_rate * short_window),
(sampling_rate * short_step))
# save st features to np file
np.save(output_file + "_st", short_features)
if plot:
print("Short-term np file: " + output_file + "_st.npy saved")
if store_csv:
# store st features to CSV file
np.savetxt(output_file + "_st.csv", short_features.T, delimiter=",")
if plot:
print("Short-term CSV file: " + output_file + "_st.csv saved")
else:
mid_features, _, _ = \
mid_feature_extraction(signal, sampling_rate,
round(sampling_rate * mid_window),
round(sampling_rate * mid_step),
round(sampling_rate * short_window),
round(sampling_rate * short_step))
# save mt features to np file
np.save(output_file, mid_features)
if plot:
print("Mid-term np file: " + output_file + ".npy saved")
if store_csv:
np.savetxt(output_file + ".csv", mid_features.T, delimiter=",")
if plot:
print("Mid-term CSV file: " + output_file + ".csv saved")
def fileClassification(inputFile, model_name, model_type):
# Load classifier:
if not os.path.isfile(model_name):
print("fileClassification: input model_name not found!")
return (-1, -1, -1)
if not os.path.isfile(inputFile):
print("fileClassification: wav file not found!")
return (-1, -1, -1)
if model_type == 'knn':
[classifier, MEAN, STD, classNames, mt_win, mt_step, st_win, st_step,
compute_beat] = load_model_knn(model_name)
else:
[classifier, MEAN, STD, classNames, mt_win, mt_step, st_win, st_step,
compute_beat] = load_model(model_name)
# read audio file and convert to mono
[Fs, x] = audioBasicIO.read_audio_file(inputFile)
x = audioBasicIO.stereo_to_mono(x)
if Fs == 0:
# audio file IO problem
return -1, -1, -1
if x.shape[0] / float(Fs) <= mt_win:
return -1, -1, -1
# feature extraction:
[mt_features, s, _] = aF.mid_feature_extraction(x, Fs, mt_win * Fs,
mt_step * Fs,
round(Fs * st_win),
round(Fs * st_step))
# long term averaging of mid-term statistics
mt_features = mt_features.mean(axis=1)
if compute_beat:
[beat, beatConf] = aF.beat_extraction(s, st_step)
mt_features = np.append(mt_features, beat)
mt_features = np.append(mt_features, beatConf)
curFV = (mt_features - MEAN) / STD # normalization
# classification
[Result, P] = classifierWrapper(classifier, model_type, curFV)
return Result, P, classNames
def directory_feature_extraction(folder_path, mid_window, mid_step,
short_window, short_step,
compute_beat=False):
"""
This function extracts the mid-term features of the WAVE files of a
particular folder.
The resulting feature vector is extracted by long-term averaging the
mid-term features.
Therefore ONE FEATURE VECTOR is extracted for each WAV file.
ARGUMENTS:
- dirName: the path of the WAVE directory
- mt_win, mt_step: mid-term window and step (in seconds)
- st_win, st_step: short-term window and step (in seconds)
"""
mid_term_features = np.array([])
process_times = []
types = ('*.wav', '*.aif', '*.aiff', '*.mp3', '*.au', '*.ogg')
wav_file_list = []
for files in types:
wav_file_list.extend(glob.glob(os.path.join(folder_path, files)))
wav_file_list = sorted(wav_file_list)
wav_file_list2, mid_feature_names = [], []
for i, file_path in enumerate(wav_file_list):
print("Analyzing file {0:d} of {1:d}: {2:s}".format(i + 1,
len(wav_file_list),
file_path))
if os.stat(file_path).st_size == 0:
print(" (EMPTY FILE -- SKIPPING)")
continue
[sampling_rate, signal] = audioBasicIO.read_audio_file(file_path)
if sampling_rate == 0:
continue
t1 = time.clock()
signal = audioBasicIO.stereo_to_mono(signal)
if signal.shape[0] < float(sampling_rate)/5:
print(" (AUDIO FILE TOO SMALL - SKIPPING)")
continue
wav_file_list2.append(file_path)
if compute_beat:
mid_features, short_features, mid_feature_names = \
mid_feature_extraction(signal, sampling_rate,
round(mid_window * sampling_rate),
round(mid_step * sampling_rate),
round(sampling_rate * short_window),
round(sampling_rate * short_step))
beat, beat_conf = beat_extraction(short_features, short_step)
else:
mid_features, _, mid_feature_names = \
mid_feature_extraction(signal, sampling_rate,
round(mid_window * sampling_rate),
round(mid_step * sampling_rate),
round(sampling_rate * short_window),
round(sampling_rate * short_step))
mid_features = np.transpose(mid_features)
mid_features = mid_features.mean(axis=0)
# long term averaging of mid-term statistics
if (not np.isnan(mid_features).any()) and \
(not np.isinf(mid_features).any()):
if compute_beat:
mid_features = np.append(mid_features, beat)
mid_features = np.append(mid_features, beat_conf)
if len(mid_term_features) == 0:
# append feature vector
mid_term_features = mid_features
else:
mid_term_features = np.vstack((mid_term_features, mid_features))
t2 = time.clock()
duration = float(len(signal)) / sampling_rate
process_times.append((t2 - t1) / duration)
if len(process_times) > 0:
print("Feature extraction complexity ratio: "
"{0:.1f} x realtime".format((1.0 /
np.mean(np.array(process_times)))))
return mid_term_features, wav_file_list2, mid_feature_names