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)