def test_spectral_flux(self):
for fs, data in self.__database:
_, data = scipy.signal.periodogram(data, fs)
data = (data + utility.epsilon) * 100
generated = spectral.spectral_flux(data, data)
reference = extractor.stSpectralFlux(data, data)
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 spectral_flux(self):
# Create some random tuple samples
frame_pairs = []
for i in range(100):
frame_index = random.randint(1, len(self.section_fft) - 1)
frame_pairs.append([
self.section_fft[frame_index],
self.section_fft[frame_index - 1]
])
# Computes the average spectral flux given paris of sample frames
flux_values = [
audioFeatureExtraction.stSpectralFlux(frame, prev)
for frame, prev in frame_pairs
]
# Returns the mean spectral flux across all frames
return mean(flux_values), stdev(flux_values)
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 test_flux(self):
for fs, data in self.__database:
generated = statistics.flux(data, data)
reference = extractor.stSpectralFlux(data, data)
self.assertAlmostEqual(generated, reference)
def F_find(x, sr):
#x, sr=librosa.load(file_name1,sr=44100,mono=True)
#print sr
sound = x
samplerate = sr
'''spec=Spectrum()
w=Windowing(type='hann')
if np.size(sound)%2!=0:
x=sound[:-1]
spc=spec(w(x))'''
#print spc
y = es.array(sound)
l = LogAttackTime()
lat, astrt, astp = l(y)
#print lat
#flu=Flux()
#s_flux=flu(spc)
#print s_flux
spec_bw = librosa.feature.spectral_bandwidth(y=x, sr=sr)
mspec_bw = np.mean(spec_bw)
#print mspec_bw
sdspec_bw = np.std(spec_bw)
#print sdspec_bw
#print mspec_bw,sdspec_bw
mfcc = librosa.feature.mfcc(y=sound, sr=samplerate, n_mfcc=11)
#print mfcc
mfcc_1 = mfcc[0]
mfcc_2 = mfcc[1]
mfcc_3 = mfcc[2]
mfcc_4 = mfcc[3]
mfcc_5 = mfcc[4]
mfcc_6 = mfcc[5]
mfcc_7 = mfcc[6]
mfcc_8 = mfcc[7]
mfcc_10 = mfcc[9]
mfcc_11 = mfcc[10]
mmfcc_1 = np.mean(mfcc_1)
mmfcc_2 = np.mean(mfcc_2)
mmfcc_3 = np.mean(mfcc_3)
mmfcc_4 = np.mean(mfcc_4)
mmfcc_5 = np.mean(mfcc_5)
mmfcc_6 = np.mean(mfcc_6)
mmfcc_7 = np.mean(mfcc_7)
mmfcc_10 = np.mean(mfcc_10)
sdmfcc_1 = np.std(mfcc_1)
sdmfcc_3 = np.std(mfcc_3)
sdmfcc_4 = np.std(mfcc_4)
sdmfcc_6 = np.std(mfcc_6)
sdmfcc_7 = np.std(mfcc_7)
sdmfcc_8 = np.std(mfcc_8)
sdmfcc_10 = np.std(mfcc_10)
sdmfcc_11 = np.std(mfcc_11)
#print sdmfcc_1,sdmfcc_3,sdmfcc_4,sdmfcc_6,sdmfcc_7,sdmfcc_8,sdmfcc_10,sdmfcc_11
#print mmfcc_1,mmfcc_2,mmfcc_3,mmfcc_4,mmfcc_5,mmfcc_6,mmfcc_7,mmfcc_10
#print mmfcc_4,mmfcc_10
'''rms=librosa.feature.rmse(y=sound)
mrms=np.mean(rms)
print mrms'''
r = RMS()
rms_e = r(y)
mrms = np.mean(rms_e)
zcr = librosa.feature.zero_crossing_rate(y=sound)
mzcr = np.mean(zcr)
sdzcr = np.std(zcr)
#print mzcr,sdzcr
cent = librosa.feature.spectral_centroid(y=sound, sr=samplerate)
mcent = np.mean(cent)
sdcent = np.std(cent)
#print mcent,sdcent
f, t, Zxx = signal.stft(sound,
44100,
window='hann',
nperseg=441,
noverlap=0)
stf = np.zeros(np.size(t))
for i in range(1, np.size(t)):
X = abs(Zxx[:, [i]])
X_prev = abs(Zxx[:, [i - 1]])
stf[i - 1] = pya.stSpectralFlux(X, X_prev)
sdsf = np.std(stf)
msf = np.mean(stf)
#print sdsf
harmo = harmonics(sound, 441)
HC = harmonicCentroid(harmo)
#print HC,'-'
HD = harmonicDeviation(harmo)
#print HD,'--'
HS = harmonicSpead(harmo)
#print HS
rawdata = {
'LogAttackTime': lat,
'RMSM': mrms,
'mfcc_1D': sdmfcc_1,
'mfcc_3D': sdmfcc_3,
'mfcc_4D': sdmfcc_4,
'mfcc_6D': sdmfcc_6,
'mfcc_7D': sdmfcc_7,
'mfcc_8D': sdmfcc_8,
'mfcc_10D': sdmfcc_10,
'mfcc_11D': sdmfcc_11,
'spectral_centroidM': mcent,
'spectral_centroidD': sdcent,
'mfcc_1M': mmfcc_1,
'mfcc_2M': mmfcc_2,
'mfcc_3M': mmfcc_3,
'mfcc_4M': mmfcc_4,
'mfcc_5M': mmfcc_5,
'mfcc_6M': mmfcc_6,
'mfcc_7M': mmfcc_7,
'mfcc_10M': mmfcc_10,
'ZCRM': mzcr,
'ZCRD': sdzcr,
'HC': HC,
'HD': HD,
'HS': HS,
'FluxM': msf,
'FluxD': sdsf,
'spectral_bandwidthM': mspec_bw,
'spectral_bandwidthD': sdspec_bw,
}
df3 = pd.DataFrame(
data=rawdata,
columns=[
'LogAttackTime', 'RMSM', 'mfcc_1D', 'mfcc_3D', 'mfcc_4D',
'mfcc_6D', 'mfcc_7D', 'mfcc_8D', 'mfcc_10D', 'mfcc_11D',
'spectral_centroidM', 'spectral_centroidD', 'mfcc_1M', 'mfcc_2M',
'mfcc_3M', 'mfcc_4M', 'mfcc_5M', 'mfcc_6M', 'mfcc_7M', 'mfcc_10M',
'ZCRM', 'ZCRD', 'HC', 'HD', 'HS', 'FluxM', 'FluxD',
'spectral_bandwidthM', 'spectral_bandwidthD'
],
index=[0])
'''print df
'''
rawdata = {
'LogAttackTime': lat,
'HD': HD,
'FluxD': sdsf,
'spectral_bandwidthM': mspec_bw,
'mfcc_1D': sdmfcc_1,
'mfcc_3D': sdmfcc_3,
'RMSM': mrms,
'spectral_bandwidthD': sdspec_bw,
'mfcc_4M': mmfcc_4,
'mfcc_11D': sdmfcc_11,
'ZCRD': sdzcr,
'spectral_centroidD': sdcent,
'mfcc_8D': sdmfcc_8,
'mfcc_6D': sdmfcc_6,
'mfcc_7D': sdmfcc_7,
'mfcc_4D': sdmfcc_4,
'spectral_centroidM': mcent,
'mfcc_10M': mmfcc_10,
'mfcc_10D': sdmfcc_10,
}
df1 = pd.DataFrame(data=rawdata,
columns=[
'LogAttackTime', 'HD', 'FluxD',
'spectral_bandwidthM', 'mfcc_1D', 'mfcc_3D', 'RMSM',
'spectral_bandwidthD', 'mfcc_4M', 'mfcc_11D',
'ZCRD', 'spectral_centroidD', 'mfcc_8D', 'mfcc_6D',
'mfcc_7D', 'mfcc_4D', 'spectral_centroidM',
'mfcc_10M', 'mfcc_10D'
],
index=[0])
rawdata = {
'spectral_centroidM': mcent,
'mfcc_2M': mmfcc_2,
'HC': HC,
'ZCRM': mzcr,
'mfcc_3M': mmfcc_3,
'HD': HD,
'ZCRD': sdzcr,
'HS': HS,
'mfcc_4M': mmfcc_4,
'mfcc_1M': mmfcc_1,
'mfcc_10M': mmfcc_10,
'FluxM': msf,
'FluxD': sdsf,
'mfcc_5M': mmfcc_5,
'mfcc_7M': mmfcc_7,
'spectral_bandwidthM': mspec_bw,
'spectral_centroidD': sdspec_bw,
'mfcc_6M': mmfcc_6,
}
df2 = pd.DataFrame(data=rawdata,
columns=[
'spectral_centroidM', 'mfcc_2M', 'HC', 'ZCRM',
'mfcc_3M', 'HD', 'ZCRD', 'HS', 'mfcc_4M', 'mfcc_1M',
'mfcc_10M', 'FluxM', 'FluxD', 'mfcc_5M', 'mfcc_7M',
'spectral_bandwidthM', 'spectral_centroidD',
'mfcc_6M'
],
index=[0])
#print df1,df2,df3
'''
f = open("dataset153.csv", 'a')
df.to_csv(f, header = False,index=False)
f.close()'''
return df1, df2, df3
