def test_spectral_rolloff(self):
for fs, data in self.__database:
percentage = random.uniform(0.0, 1.0)
_, data = scipy.signal.periodogram(data, fs)
data = (data + utility.epsilon) * 100
generated = spectral.spectral_rolloff(data, percentage)
reference = extractor.stSpectralRollOff(data, percentage, fs)
self.assertAlmostEqual(generated, reference.item(), 5)
def _function(self, recording):
time_frames = recording.shape[0]
features = np.zeros([time_frames, 14], np.float32)
for time in range(time_frames):
frame = recording[time, :]
X_new = np.abs(np.fft.rfft(frame))
X_prev = X if time else np.zeros_like(np.fft.rfft)
X = X_new
features[time, 0] = aF.stZCR(frame)
features[time, 1] = aF.stEnergy(frame)
features[time, 2] = aF.stEnergyEntropy(frame)
features[time, 3:5] = aF.stSpectralCentroidAndSpread(X + 2e-12, self.sr)
features[time, 5] = aF.stSpectralEntropy(X)
features[time, 6] = aF.stSpectralRollOff(X, 0.85, self.sr)
features[time, 7] = aF.stSpectralFlux(X, X_prev)
features[time, 8:14] = HandCrafted.formants(frame) / 1000 # division for normalization (results in kHz)
return features
def stFeatureExtraction(signal, fs, win, step, feats):
"""
This function implements the shor-term windowing process. For each short-term window a set of features is extracted.
This results to a sequence of feature vectors, stored in a numpy matrix.
ARGUMENTS
signal: the input signal samples
fs: the sampling freq (in Hz)
win: the short-term window size (in samples)
step: the short-term window step (in samples)
steps: list of main features to compute ("mfcc" and/or "gfcc")
RETURNS
st_features: a numpy array (n_feats x numOfShortTermWindows)
"""
if "gfcc" in feats:
ngfcc = 22
gfcc = getGfcc.GFCCFeature(fs)
else:
ngfcc = 0
if "mfcc" in feats:
n_mfcc_feats = 13
else:
n_mfcc_feats = 0
win = int(win)
step = int(step)
# Signal normalization
signal = numpy.double(signal)
signal = signal / (2.0**15)
DC = signal.mean()
MAX = (numpy.abs(signal)).max()
signal = (signal - DC) / (MAX + 0.0000000001)
N = len(signal) # total number of samples
cur_p = 0
count_fr = 0
nFFT = int(win / 2)
[fbank, freqs] = mfccInitFilterBanks(
fs, nFFT
) # compute the triangular filter banks used in the mfcc calculation
n_harmonic_feats = 0
feature_names = []
if "spectral" in feats:
n_time_spectral_feats = 8
feature_names.append("zcr")
feature_names.append("energy")
feature_names.append("energy_entropy")
feature_names += ["spectral_centroid", "spectral_spread"]
feature_names.append("spectral_entropy")
feature_names.append("spectral_flux")
feature_names.append("spectral_rolloff")
else:
n_time_spectral_feats = 0
if "mfcc" in feats:
feature_names += [
"mfcc_{0:d}".format(mfcc_i)
for mfcc_i in range(1, n_mfcc_feats + 1)
]
if "gfcc" in feats:
feature_names += [
"gfcc_{0:d}".format(gfcc_i) for gfcc_i in range(1, ngfcc + 1)
]
if "chroma" in feats:
nChroma, nFreqsPerChroma = stChromaFeaturesInit(nFFT, fs)
n_chroma_feats = 13
feature_names += [
"chroma_{0:d}".format(chroma_i)
for chroma_i in range(1, n_chroma_feats)
]
feature_names.append("chroma_std")
else:
n_chroma_feats = 0
n_total_feats = n_time_spectral_feats + n_mfcc_feats + n_harmonic_feats + n_chroma_feats + ngfcc
st_features = []
while (cur_p + win - 1 <
N): # for each short-term window until the end of signal
count_fr += 1
x = signal[cur_p:cur_p + win] # get current window
cur_p = cur_p + step # update window position
X = abs(fft(x)) # get fft magnitude
X = X[0:nFFT] # normalize fft
X = X / len(X)
if count_fr == 1:
X_prev = X.copy() # keep previous fft mag (used in spectral flux)
curFV = numpy.zeros((n_total_feats, 1))
if "spectral" in feats:
curFV[0] = stZCR(x) # zero crossing rate
curFV[1] = stEnergy(x) # short-term energy
curFV[2] = stEnergyEntropy(x) # short-term entropy of energy
[curFV[3], curFV[4]] = stSpectralCentroidAndSpread(
X, fs) # spectral centroid and spread
curFV[5] = stSpectralEntropy(X) # spectral entropy
curFV[6] = stSpectralFlux(X, X_prev) # spectral flux
curFV[7] = stSpectralRollOff(X, 0.90, fs) # spectral rolloff
if "mfcc" in feats:
curFV[n_time_spectral_feats:n_time_spectral_feats+n_mfcc_feats, 0] = \
stMFCC(X, fbank, n_mfcc_feats).copy() # MFCCs
if "gfcc" in feats:
curFV[n_time_spectral_feats + n_mfcc_feats:n_time_spectral_feats +
n_mfcc_feats + ngfcc, 0] = gfcc.get_gfcc(x)
if "chroma" in feats:
chromaNames, chromaF = stChromaFeatures(X, fs, nChroma,
nFreqsPerChroma)
curFV[n_time_spectral_feats + n_mfcc_feats + ngfcc:
n_time_spectral_feats + n_mfcc_feats + n_chroma_feats + ngfcc - 1] = \
chromaF
curFV[n_time_spectral_feats + n_mfcc_feats + n_chroma_feats + ngfcc - 1] = \
chromaF.std()
st_features.append(curFV)
X_prev = X.copy()
st_features = numpy.concatenate(st_features, 1)
return st_features, feature_names
def feature_engineer(self, audio_data):
"""
Extract features using librosa.feature.
Each signal is cut into frames, features are computed for each frame and averaged [median].
The numpy array is transformed into a data frame with named columns.
:param audio_data: the input signal samples with frequency 44.1 kHz
:return: a numpy array (numOfFeatures x numOfShortTermWindows)
"""
loop_length = len(audio_data) / self.FRAME
concat_feat = []
zcr_feat = []
rmse_feat = []
spectral_bandwidth_feat = []
spectral_centroid_feat = []
spectral_rolloff_feat = []
mfcc_feat = np.empty(shape=[13, 0])
for i in range(loop_length):
audio_data_batch = (audio_data[i * loop_length:(i * loop_length) +
loop_length])
zcr_feat_1 = af.stZCR(audio_data_batch)
zcr_feat.append(zcr_feat_1)
rmse_feat_1 = af.stEnergy(audio_data_batch)
rmse_feat.append(rmse_feat_1)
if rmse_feat_1.shape == (1, 427):
rmse_feat_1 = np.concatenate((rmse_feat, np.zeros((1, 4))),
axis=1)
[fbank, freqs] = af.mfccInitFilterBanks(self.RATE, self.nFFT)
#mfcc_feat = af.stMFCC(audio_data, fbank, 13)
mfcc_feat_1 = psf.mfcc(audio_data_batch, self.RATE, nfft=1103)
# mfcc_feat_1 = np.squeeze(mfcc_feat_1).shape
mfcc_feat_1 = np.transpose(mfcc_feat_1)
mfcc_feat = np.append(mfcc_feat, mfcc_feat_1, axis=1)
spectral_centroid_and_spread_1 = af.stSpectralCentroidAndSpread(
audio_data_batch, self.RATE)
spectral_centroid_feat_1 = spectral_centroid_and_spread_1[0]
spectral_centroid_feat.append(spectral_centroid_feat_1)
spectral_bandwidth_feat_1 = spectral_centroid_and_spread_1[1]
spectral_bandwidth_feat.append(spectral_bandwidth_feat_1)
spectral_rolloff_feat_1 = af.stSpectralRollOff(
audio_data_batch, 0.90, self.RATE)
spectral_rolloff_feat.append(spectral_rolloff_feat_1)
# chroma_cens_feat = chroma_cens(y=audio_data, sr=self.RATE, hop_length=self.FRAME)
# zcr_feat = np.asarray(zcr_feat)
# rmse_feat = np.asarray(rmse_feat)
# spectral_bandwidth_feat = np.asarray(spectral_bandwidth_feat)
# spectral_centroid_feat = np.asarray(spectral_centroid_feat)
# spectral_rolloff_feat = np.asarray(spectral_rolloff_feat)
concat_feat.append(zcr_feat)
concat_feat.append(rmse_feat)
concat_feat.append(spectral_bandwidth_feat)
concat_feat.append(spectral_centroid_feat)
concat_feat.append(spectral_rolloff_feat)
# concat_feat.append(mfcc_feat)
# mfcc_feat = np.asarray(mfcc_feat, dtype=np.float32)
concat_feat = np.array(concat_feat)
concat_feat = np.concatenate((concat_feat, mfcc_feat), axis=0)
# print concat_feat.shape
return np.mean(concat_feat, axis=1,
keepdims=True).transpose(), self.label
def test_rolloff(self):
for fs, data in self.__database:
percentage = random.uniform(0.0, 1.0)
generated = statistics.rolloff(data, percentage)
reference = extractor.stSpectralRollOff(data, percentage, fs)
self.assertAlmostEqual(generated, reference)
def spectral_roll_off(self):
# Easy one liner for computing spectral roll off
# In testing I found that 0.5 gave good values. Any higher or lower and the value ended up being very clustered
return audioFeatureExtraction.stSpectralRollOff(
self.section, .5, self.sampling_rate)