def test_spectral_contrast(self):
correct = rosaft.spectral_contrast(y=self.sig,
sr=self.fs,
S=None,
n_fft=nfft,
hop_length=stepsize)
actual = spectral_contrast(self.args)
self.assertTrue(np.abs(correct - actual).max() < tol)
def spectral_contrast(args):
psd = get_psd(args)
fs, nfft, noverlap = unroll_args(args, ['fs', 'nfft', 'noverlap'])
hopsize = nfft - noverlap
if fs < 12800:
n_bands = 6
fmin = int(fs / 2.0**(n_bands))
else:
fmin = 200
return rosaft.spectral_contrast(y=None,
sr=fs,
S=psd,
n_fft=nfft,
hop_length=hopsize,
fmin=fmin)
def extract_features(self):
# Generates a Short-time Fourier transform (STFT) to use in the chroma_stft
stft = np.abs(librosa.stft(self.waveform))
# Generate Mel-frequency cepstral coefficients (MFCCs) from a time series
mfccs = mfcc(y=self.waveform, sr=self.sample_rate,
n_mfcc=40).mean(axis=1)
# Computes a chromagram from a waveform or power spectrogram.
chroma = chroma_stft(S=stft, sr=self.sample_rate).mean(axis=1)
# Computes a mel-scaled spectrogram.
mel = melspectrogram(self.waveform, sr=self.sample_rate).mean(axis=1)
# Computes spectral contrast
contrast = spectral_contrast(S=stft, sr=self.sample_rate).mean(axis=1)
# Computes the tonal centroid features (tonnetz)
harmonic = librosa.effects.harmonic(self.waveform)
tonn = tonnetz(y=harmonic, sr=self.sample_rate).mean(axis=1)
return np.concatenate([mfccs, chroma, mel, contrast, tonn], axis=0)
def feature_extraction_all(signal, sr, n_mfcc, buffer_len,
normalization_values):
"""
Feature extraction interface
:param signal: Signal
:param sr: Signal
:param n_mfcc: Signal
:param buffer_len: Signal
:param normalization_values: normalization values of the dataset
:output features: Array of features
Features are extracted from the incoming audio signal when an onset is detected.
"""
features = []
signal = np.array(signal)
if signal.size != 0:
S, phase = librosa.magphase(
librosa.stft(y=signal,
n_fft=buffer_len,
hop_length=int(buffer_len / 4)))
# Mel Frequency cepstral coefficients
mfcc = feature.mfcc(y=signal,
sr=sr,
n_mfcc=n_mfcc,
n_fft=int(512 * 2),
hop_length=int(128 * 2))
mfcc_mean = np.mean(mfcc, axis=1)
mfcc_std = np.std(mfcc, axis=1)
# RMS
rms = feature.rms(S=S,
frame_length=buffer_len,
hop_length=int(buffer_len / 4))
rms_mean = np.mean(rms, axis=1)
rms_std = np.std(rms, axis=1)
# Spectral Centroid
spectral_centroid = feature.spectral_centroid(S=S, sr=sr)
spectral_centroid_mean = np.mean(spectral_centroid, axis=1)
spectral_centroid_std = np.std(spectral_centroid, axis=1)
# Rolloff
spectral_rolloff = feature.spectral_rolloff(S=S, sr=sr)
spectral_rolloff_mean = np.mean(spectral_rolloff, axis=1)
spectral_rolloff_std = np.std(spectral_rolloff, axis=1)
# Bandwidth
spectral_bandwidth = feature.spectral_bandwidth(S=S, sr=sr)
spectral_bandwidth_mean = np.mean(spectral_bandwidth, axis=1)
spectral_bandwidth_std = np.std(spectral_bandwidth, axis=1)
# Contrast
spectral_contrast = feature.spectral_contrast(S=S, sr=sr)
spectral_contrast_mean = np.mean(spectral_contrast, axis=1)
spectral_contrast_std = np.std(spectral_contrast, axis=1)
# Flatness
spectral_flatness = feature.spectral_flatness(S=S)
spectral_flatness_mean = np.mean(spectral_flatness, axis=1)
spectral_flatness_std = np.std(spectral_flatness, axis=1)
if len(normalization_values) > 1:
# Duration
features.append(
normalize(len(signal), normalization_values['duration']))
features.extend(
normalize(
mfcc_mean, normalization_values[[
'mfcc_mean_1', 'mfcc_mean_2', 'mfcc_mean_3',
'mfcc_mean_4', 'mfcc_mean_5', 'mfcc_mean_6',
'mfcc_mean_7', 'mfcc_mean_8', 'mfcc_mean_9',
'mfcc_mean_10'
]]))
features.extend(
normalize(
mfcc_std, normalization_values[[
'mfcc_std_1', 'mfcc_std_2', 'mfcc_std_3', 'mfcc_std_4',
'mfcc_std_5', 'mfcc_std_6', 'mfcc_std_7', 'mfcc_std_8',
'mfcc_std_9', 'mfcc_std_10'
]]))
features.extend(
normalize(rms_mean, normalization_values['rms_mean']))
features.extend(normalize(rms_std,
normalization_values['rms_std']))
features.extend(
normalize(spectral_centroid_mean,
normalization_values['spectral_centroid_mean']))
features.extend(
normalize(spectral_centroid_std,
normalization_values['spectral_centroid_std']))
features.extend(
normalize(spectral_rolloff_mean,
normalization_values['spectral_rolloff_mean']))
features.extend(
normalize(spectral_rolloff_std,
normalization_values['spectral_rolloff_std']))
features.extend(
normalize(spectral_bandwidth_mean,
normalization_values['spectral_bandwidth_mean']))
features.extend(
normalize(spectral_bandwidth_std,
normalization_values['spectral_bandwidth_std']))
features.extend(
normalize(
spectral_contrast_mean, normalization_values[[
'spectral_contrast_mean_1', 'spectral_contrast_mean_2',
'spectral_contrast_mean_3', 'spectral_contrast_mean_4',
'spectral_contrast_mean_5', 'spectral_contrast_mean_6',
'spectral_contrast_mean_7'
]]))
features.extend(
normalize(
spectral_contrast_std, normalization_values[[
'spectral_contrast_std_1', 'spectral_contrast_std_2',
'spectral_contrast_std_3', 'spectral_contrast_std_4',
'spectral_contrast_std_5', 'spectral_contrast_std_6',
'spectral_contrast_std_7'
]]))
features.extend(
normalize(spectral_flatness_mean,
normalization_values['spectral_flatness_mean']))
features.extend(
normalize(spectral_flatness_std,
normalization_values['spectral_flatness_std']))
else:
features.append(len(signal))
features.extend(mfcc_mean)
features.extend(mfcc_std)
features.extend(rms_mean)
features.extend(rms_std)
features.extend(spectral_centroid_mean)
features.extend(spectral_centroid_std)
features.extend(spectral_rolloff_mean)
features.extend(spectral_rolloff_std)
features.extend(spectral_bandwidth_mean)
features.extend(spectral_bandwidth_std)
features.extend(spectral_contrast_mean)
features.extend(spectral_contrast_std)
features.extend(spectral_flatness_mean)
features.extend(spectral_flatness_std)
features = np.array(features)
return features
def extract_features(soundwave,sampling_rate,sound_name="test",feature_list=[]):
"""
extracts features with help of librosa
:param soundwave: extracted soundwave from file
:param sampling_rate: sampling rate
:param feature_list: list of features to compute
:param sound_name: type of sound, i.e. dog
:return: np.array of all features for the soundwave
"""
print("Computing features for ",sound_name)
if len(feature_list)==0:
feature_list=["chroma_stft","chroma_cqt","chroma_cens","melspectrogram",
"mfcc","rmse","spectral_centroid","spectral_bandwidth",
"spectral_contrast","spectral_flatness","spectral_rolloff",
"poly_features","tonnetz","zero_crossing_rate"]
features=[]
#feature_len
#"chroma_stft":12
if "chroma_stft" in feature_list:
features.append(feat.chroma_stft(soundwave, sampling_rate))
#"chroma_cqt":12
if "chroma_cqt" in feature_list:
features.append(feat.chroma_cqt(soundwave, sampling_rate))
#"chroma_cens":12
if "chroma_cens" in feature_list:
features.append(feat.chroma_cens(soundwave, sampling_rate))
#"malspectrogram":128
if "melspectrogram" in feature_list:
features.append(feat.melspectrogram(soundwave, sampling_rate))
#"mfcc":20
if "mfcc" in feature_list:
features.append(feat.mfcc(soundwave, sampling_rate))
#"rmse":1
if "rmse" in feature_list:
features.append(feat.rmse(soundwave))
#"spectral_centroid":1
if "spectral_centroid" in feature_list:
features.append(feat.spectral_centroid(soundwave, sampling_rate))
#"spectral_bandwidth":1
if "spectral_bandwidth" in feature_list:
features.append(feat.spectral_bandwidth(soundwave, sampling_rate))
#"spectral_contrast":7
if "spectral_contrast" in feature_list:
features.append(feat.spectral_contrast(soundwave, sampling_rate))
#"spectral_flatness":1
if "spectral_flatness" in feature_list:
features.append(feat.spectral_flatness(soundwave))
#"spectral_rolloff":1
if "spectral_rolloff" in feature_list:
features.append(feat.spectral_rolloff(soundwave, sampling_rate))
#"poly_features":2
if "poly_features" in feature_list:
features.append(feat.poly_features(soundwave, sampling_rate))
#"tonnetz":6
if "tonnetz" in feature_list:
features.append(feat.tonnetz(soundwave, sampling_rate))
#"zero_crossing_rate":1
if "zero_crossing_rate" in feature_list:
features.append(feat.zero_crossing_rate(soundwave))
return np.concatenate(features)
row = np.concatenate((row, sens))
spcent = np.mean(lf.spectral_centroid(thing1[:-1]).T, axis=0)
row = np.concatenate((row, spcent))
flatness = np.mean(lf.spectral_flatness(thing1[:-1]).T, axis=0)
row = np.concatenate((row, flatness))
rolloff = np.mean(lf.spectral_rolloff(thing1[:-1]).T, axis=0)
row = np.concatenate((row, rolloff))
mspec = np.mean(lf.melspectrogram(thing1[:-1]).T, axis=0)
row = np.concatenate((row, mspec))
mfcc = np.mean(lf.mfcc(thing1[:-1], n_mfcc=30).T, axis=0)
row = np.concatenate((row, mfcc))
tonnetz = np.mean(lf.tonnetz(thing1[:-1]).T, axis=0)
row = np.concatenate((row, tonnetz))
rmse = np.mean(lf.rmse(thing1[:-1]).T, axis=0)
row = np.concatenate((row, rmse))
contrast = np.mean(lf.spectral_contrast(thing1[:-1]).T, axis=0)
row = np.concatenate((row, contrast))
tempo = np.mean(lf.tempogram(thing[:-1], win_length=88).T, axis=0)
row = np.concatenate((row, tempo))
row = np.append(row, thing1[-1])
#print(len(row))
train_data = np.append(train_data, row)
counter += 1
columns = ["feat_" + str(i) for i in range(299)]
columns.append("class")
df_train2 = pd.DataFrame(columns=columns)
for i in range(6325):
print(float(i) / 6325. * 100)
def Features_Audio(Fenetres,
TailleFenetre,
EcartSousFenetres,
fen_anal=100,
center=True):
# TailleFenetre est donné en secondes et correspond à la taille des fenetres de texture
# Ecartsousfenetre est donné en proportion de de fen_anal (0,5 pour un recouvrement de deux fenêtres, 1/3 pour 3 fenetres, 1 pas de recouvrement)
# Fen_anal en ms (taille de la fenêtre d'analyse)
# une ligne par fenêtre
# une colonne par feature
# Retour_X une liste des features par fenetre
Retour_X = []
win_l = hz * fen_anal / 1000
hop_l = int(win_l * EcartSousFenetres)
win_l = int(win_l)
for DebutFenetre in Fenetres:
Fenetre = Signal[int(DebutFenetre * hz):int(DebutFenetre * hz +
TailleFenetre * hz)]
D = np.abs(
librosa.stft(Fenetre,
window=window,
n_fft=win_l,
win_length=win_l,
hop_length=hop_l,
center=center))**2
# calcul du MEL
S = feature.melspectrogram(S=D,
y=Fenetre,
n_mels=n_MEL,
fmin=fmin,
fmax=fmax)
# calcul des 13 coefficients
mfcc = feature.mfcc(S=librosa.power_to_db(S), n_mfcc=n_mfcc)
# Calcul de la dérivée
mfcc_delta = feature.delta(mfcc)
# Calcul de la dérivée seconde
mfcc_delta2 = feature.delta(mfcc_delta)
# Zero crossing rate
ZCR = feature.zero_crossing_rate(Fenetre,
frame_length=win_l,
hop_length=hop_l,
center=center,
threshold=1e-10)
# spectral contrast
SCo = feature.spectral_contrast(S=D,
sr=hz,
n_fft=win_l,
hop_length=512,
fmin=fmin,
quantile=0.02)
# Intégration temporelle
mfcc = np.mean(mfcc, axis=1)
mfcc_delta = np.mean(mfcc_delta, axis=1)
mfcc_delta2 = np.mean(mfcc_delta2, axis=1)
ZCR = np.mean(ZCR)
SCo = np.mean(SCo)
# Concatenation des features
f = np.hstack((mfcc, mfcc_delta, mfcc_delta2, ZCR, SCo))
# on transpose (feature en colonne) et rajoute les lignes correspondant aux nouvelles fenêtres
Retour_X.append(f.tolist())
return np.array(Retour_X)
def get_feature_from_librosa(wave_name, window):
#print wave_name
(rate, sig) = wav.read(wave_name)
chroma_stft_feat = feature.chroma_stft(sig,
rate,
n_fft=window,
hop_length=window / 2)
#print chroma_stft_feat.shape
mfcc_feat = feature.mfcc(y=sig, sr=rate, n_mfcc=13, hop_length=window / 2)
mfcc_feat = mfcc_feat[1:, :]
#print mfcc_feat.shape
d_mfcc_feat = feature.delta(mfcc_feat)
#print d_mfcc_feat.shape
d_d_mfcc_feat = feature.delta(d_mfcc_feat)
#print d_d_mfcc_feat.shape
zero_crossing_rate_feat = feature.zero_crossing_rate(sig,
frame_length=window,
hop_length=window / 2)
#print zero_crossing_rate_feat.shape
S = librosa.magphase(
librosa.stft(sig,
hop_length=window / 2,
win_length=window,
window='hann'))[0]
rmse_feat = feature.rmse(S=S)
#print rmse_feat.shape
centroid_feat = feature.spectral_centroid(sig,
rate,
n_fft=window,
hop_length=window / 2)
#print centroid_feat.shape
bandwith_feat = feature.spectral_bandwidth(sig,
rate,
n_fft=window,
hop_length=window / 2)
#print bandwith_feat.shape
contrast_feat = feature.spectral_contrast(sig,
rate,
n_fft=window,
hop_length=window / 2)
#print contrast_feat.shape
rolloff_feat = feature.spectral_rolloff(sig,
rate,
n_fft=window,
hop_length=window / 2) #计算滚降频率
#print rolloff_feat.shape
poly_feat = feature.poly_features(sig,
rate,
n_fft=window,
hop_length=window /
2) #拟合一个n阶多项式到谱图列的系数。
#print poly_feat.shape
#==============================================================================
# print(chroma_stft_feat.shape)
# #print(corr_feat.shape)
# print(mfcc_feat.shape)
# print(d_mfcc_feat.shape)
# print(d_d_mfcc_feat.shape)
# print(zero_crossing_rate_feat.shape)
# print(rmse_feat.shape)
# print(centroid_feat.shape)
# print(bandwith_feat.shape)
# print(contrast_feat.shape)
# print(rolloff_feat.shape)
# print(poly_feat.shape)
#==============================================================================
feat = numpy.hstack(
(chroma_stft_feat.T, mfcc_feat.T, d_mfcc_feat.T, d_d_mfcc_feat.T,
zero_crossing_rate_feat.T, rmse_feat.T, centroid_feat.T,
bandwith_feat.T, contrast_feat.T, rolloff_feat.T, poly_feat.T))
feat = feat.T
return feat #一行代表一帧的特征
def get_features(sig, sensor_id):
"""Analysis of a signal. Grabs temporal and frequential features.
Returns a pandas dataframe"""
fourier = fftpack.fft(sig.values)
real, imag = np.real(fourier), np.imag(fourier)
# Temporal data
features = {}
features[f"{sensor_id}_mean"] = [sig.mean()]
features[f"{sensor_id}_var"] = [sig.var()]
features[f"{sensor_id}_skew"] = [sig.skew()]
features[f"{sensor_id}_delta"] = [sig.max() - sig.min()]
features[f"{sensor_id}_mad"] = [sig.mad()]
features[f"{sensor_id}_kurtosis"] = [sig.kurtosis()]
features[f"{sensor_id}_sem"] = [sig.sem()]
features[f"{sensor_id}_q5"] = [np.quantile(sig, 0.05)]
features[f"{sensor_id}_q25"] = [np.quantile(sig, 0.25)]
features[f"{sensor_id}_q75"] = [np.quantile(sig, 0.75)]
features[f"{sensor_id}_q95"] = [np.quantile(sig, 0.95)]
grad_rol_max = [maximum_filter1d(np.gradient(np.abs(sig.values)), 50)]
delta = np.max(grad_rol_max) - np.min(grad_rol_max)
features[f"{sensor_id}_grmax_delta"] = delta
# Frequencial
features[f"{sensor_id}_real_mean"] = [real.mean()]
features[f"{sensor_id}_real_var"] = [real.var()]
features[f"{sensor_id}_real_delta"] = [real.max() - real.min()]
features[f"{sensor_id}_imag_mean"] = [imag.mean()]
features[f"{sensor_id}_imag_var"] = [imag.var()]
features[f"{sensor_id}_imag_delta"] = [imag.max() - imag.min()]
features[f"{sensor_id}_nb_peak"] = fc.number_peaks(sig.values, 2)
features[f"{sensor_id}_median_roll_std"] = np.median(
pd.Series(sig).rolling(50).std().dropna().values)
features[f"{sensor_id}_autocorr5"] = fc.autocorrelation(sig, 5)
# Added 16
features[f"{sensor_id}_nb_peak_3"] = fc.number_peaks(sig.values, 3)
features[f"{sensor_id}_absquant95"] = np.quantile(np.abs(sig), 0.95)
try:
# Mel-frequency cepstral coefficients
mfcc_mean = mfcc(sig.values).mean(axis=1)
for i in range(20):
features[f"{sensor_id}_mfcc_mean_{i}"] = mfcc_mean[i]
# Contrast spectral
spec_contrast = spectral_contrast(sig.values).mean(axis=1)
for i in range(7):
features[f"{sensor_id}_lib_spec_cont_{i}"] = spec_contrast[i]
features[f"{sensor_id}_zero_cross"] = zero_crossing_rate(sig)[0].mean()
# Added 16
features[f"{sensor_id}_percentile_roll20_std_50"] = np.percentile(
sig.rolling(20).std().dropna().values, 50)
except:
pass
# =============================================================================
# fftrhann20000 = np.sum(np.abs(np.fft.fft(np.hanning(len(z))*z)[:20000]))
# fftrhann20000_denoise = np.sum(np.abs(np.fft.fft(np.hanning(len(z))*den_sample)[:20000]))
# fftrhann20000_diff_rate = (fftrhann20000 - fftrhann20000_denoise)/fftrhann20000
# X['LGBM_fftrhann20000_diff_rate'] = fftrhann20000_diff_rate
# =============================================================================
return pd.DataFrame.from_dict(features)
def spectral_contrast(args):
psd = get_psd(args)
fs, nfft, noverlap = unroll_args(args, ['fs', 'nfft', 'noverlap'])
hopsize = nfft - noverlap
return rosaft.spectral_contrast(y=None, sr=fs, S=psd, n_fft=nfft, hop_length=hopsize)
