Пример #1
0
def get_audio_features_dataframe(n_mfcc):
    """Extract specified audio features from all audio files
    and store as csv
    Args:
        n_mfcc (int): number of MFCC values to extract
    Returns: None
    """
    df = pd.DataFrame()

    for member, label in MEMBER_TO_LABEL.items():
        print(member, end=' ')
        files = os.listdir(f'data/{label}')
        files = [f'data/{label}/{x}' for x in files]
        rows = []

        for f in files:
            # Aggregated MFCC values, so that each audio is represented
            # by a 1D array of length n_mfcc
            x, sample_rate = load_audio(file_path=f, sample_rate=44100/3)
            mfcc_feat = MFCC(y=x, sr=sample_rate, n_mfcc=n_mfcc)
            mfcc_mean = mfcc_feat.mean(axis=1)
            zero_crossing = sum(librosa.zero_crossings(y=x))
            centroids = librosa.feature.spectral_centroid(y=x, sr=sample_rate)

            # Each coefficient is a feature column
            row = {'label': label, 'file_path': f}
            for number, coef in enumerate(mfcc_mean):
                row[f'mfcc_{n_mfcc}_{number + 1:02d}'] = coef
            row['zero_crossing'] = zero_crossing
            row['spectral_centroid'] = np.mean(centroids)
            rows.append(row)
        df = df.append(rows, ignore_index=True)

    df.to_csv(f'features.csv', index=False)
Пример #2
0
def feature_extration(x, sr):
    # Zero Crossing Rate
    n0 = 9000
    n1 = 9100
    zero_crossings = librosa.zero_crossings(x[n0:n1], pad=False)
    # Spectral Centroid
    spectral_centroids = librosa.feature.spectral_centroid(x, sr=sr)[0]
    #print("sc",spectral_centroids[0] )

    # Spectral Rolloff
    spectral_rolloff = librosa.feature.spectral_rolloff(x + 0.01, sr=sr)[0]
    #print("sr",spectral_rolloff[0] )

    # Mel-Frequency Cepstral Coefficients
    mfccs = librosa.feature.mfcc(x, sr)
    mfccs = mfccs.flatten()
    #print("mfccs",mfccs.shape)

    # Chroma Frequencies
    hop_length = 512
    chromagram = librosa.feature.chroma_stft(x, sr=sr, hop_length=hop_length)
    chromagram = chromagram.flatten()
    #print("c",chromagram.shape )

    feature = [
        x for x_set in [[sum(zero_crossings)], spectral_centroids[:5],
                        spectral_rolloff[:5], mfccs[:5], chromagram[:5]]
        for x in x_set
    ]
    return np.array(feature)
Пример #3
0
def get_mean_zero_crossing(x):
    zero_crossing = librosa.zero_crossings(x, pad=False)
    converted_array = [int(elem)
                       for elem in zero_crossing]  # convert T/F to 1/0
    bumped_array = [elem * 10000 for elem in converted_array]
    mean_zero_crossing = np.mean(bumped_array)
    return mean_zero_crossing
def pad_end(data, length):

    pad = data.loc[data.sample_count < length]

    cropped = []
    indexes = []
    samples = []

    for index, row in pad.iterrows():
        sample = row['raw_sounds']
        l = len(sample)

        z = librosa.zero_crossings(sample)
        crossings = np.nonzero(z)
        begin = crossings[0][0]
        end = crossings[0][-1]
        y = sample[begin:end + 1]

        cropped.append(y)
        indexes.append(index)
        samples.append(len(y))

    output = pd.DataFrame(list(zip(cropped, indexes, samples)),
                          columns=['raw_sounds', 'index',
                                   'sample_count']).set_index('index')

    data.update(output)  # Join resampled recordings to raw frame

    return data
Пример #5
0
def get_sound_feature(filename):
    
    #過零率:zero_crossing
    x, sr = librosa.load(filename) 
    n0 = 9000
    n1 = 9100
    zero_crossings = librosa.zero_crossings(x[0:len(x)-1], pad=False) 

    #光譜質心:spectral_centroids
    spectral_centroids = librosa.feature.spectral_centroid(x, sr=sr)[0]
    spectral_centroids.shape
    def normalize(x, axis=0): 
        return sklearn.preprocessing.minmax_scale(x, axis=axis) 
    normalize_spectral_centroids = normalize(spectral_centroids)

    #光譜衰減:spectral_rolloff
    spectral_rolloff = librosa.feature.spectral_rolloff(x+0.01, sr=sr)[0] 

    #梅爾頻率倒譜系數:mfccs.mean/ mfccs.var
    x, fs = librosa.load(filename) 
    mfccs = librosa.feature.mfcc(x, sr=fs) 
    mfccs.shape
    mfccs = sklearn.preprocessing.scale(mfccs, axis=1) 
    #print(mfccs.mean(axis=1)) 
    #print(mfccs.var(axis=1)) 

    #色度頻率:chromagram
    x, sr = librosa.load(filename) 
    chromagram = librosa.feature.chroma_stft(x, sr=sr) 
    
    return sum(zero_crossings), spectral_centroids, spectral_rolloff, mfccs, chromagram, x
Пример #6
0
def zcr_features(fname):
    """
    Compute zero crossing rate"
    """
    rate, signal = wavfile.read(fname)
    zcr_feat = librosa.zero_crossings(signal, pad=False)
    return np.atleast_1d(np.sum(zcr_feat))
Пример #7
0
def extract_zero_crossing(y, sr, repeat_length):
    zero_crossings = librosa.zero_crossings(y, pad=False)
    zcrsum = sum(zero_crossings)
    zcrsum = np.repeat(zcrsum, repeat_length)
    zcrsum = np.reshape(zcrsum, (-1, 1))
    zcrsum = zcrsum.T

    return zcrsum
Пример #8
0
 def compute_TFeatures(self):
     """ COmpute temporal features such as zero crossing and ZCR
     returns: tuple of ZCR od ZC index ZCR: np.ndarray ZC idx: tuple
     """
     return (lbr.feature.zero_crossing_rate(y=self.audio,
         frame_length=self.fft_len, \
                 hop_length=self.hop, center=False), \
     np.nonzero(lbr.zero_crossings(y=self.audio)))
Пример #9
0
def audio_features(filename):

    hop_length = 512
    n_fft = 2048

    #load file
    y, sr = librosa.load(filename)
    duration = float(librosa.core.get_duration(y))
    #extract features from librosa
    tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)
    beat_times = librosa.frames_to_time(beat_frames, sr=sr)
    y_harmonic, y_percussive = librosa.effects.hpss(y)
    mfcc = librosa.feature.mfcc(y=y, sr=sr, hop_length=hop_length, n_mfcc=13)
    mfcc_delta = librosa.feature.delta(mfcc)
    beat_mfcc_delta = librosa.util.sync(np.vstack([mfcc, mfcc_delta]),
                                        beat_frames)
    chromagram = librosa.feature.chroma_cqt(y=y_harmonic, sr=sr)
    beat_chroma = librosa.util.sync(chromagram,
                                    beat_frames,
                                    aggregate=np.median)
    beat_features = np.vstack([beat_chroma, beat_mfcc_delta])
    zero_crossings = librosa.zero_crossings(y)
    zero_crossing_time = librosa.feature.zero_crossing_rate(y)
    spectral_centroid = librosa.feature.spectral_centroid(y)
    spectral_bandwidth = librosa.feature.spectral_bandwidth(y)
    spectral_contrast = librosa.feature.spectral_contrast(y)
    spectral_rolloff = librosa.feature.spectral_rolloff(y)
    rmse = librosa.feature.rmse(y)
    poly_features = librosa.feature.poly_features(y)
    chroma_stft = librosa.feature.chroma_stft(y)
    chroma_cens = librosa.feature.chroma_cens(y)
    tonnetz = librosa.feature.tonnetz(y)

    mfcc_all = statlist(mfcc)
    mfccd_all = statlist(mfcc_delta)
    bmfccd_all = statlist(beat_mfcc_delta)
    cg_all = statlist(chromagram)
    bc_all = statlist(beat_chroma)
    bf_all = statlist(beat_features)
    zc_all = statlist(zero_crossings)
    sc_all = statlist(spectral_centroid)
    sb_all = statlist(spectral_bandwidth)
    sc_all = statlist(spectral_contrast)
    sr_all = statlist(spectral_rolloff)
    rmse_all = statlist(rmse)
    pf_all = statlist(poly_features)
    cstft_all = statlist(chroma_stft)
    ccens_all = statlist(chroma_cens)
    tonnetz_all = statlist(tonnetz)

    return [
        duration,
        float(tempo),
        beat_frames.tolist(),
        beat_times.tolist(), mfcc_all, mfccd_all, bmfccd_all, cg_all, bc_all,
        bf_all, zc_all, sc_all, sb_all, sc_all, sr_all, rmse_all, pf_all,
        cstft_all, ccens_all, tonnetz_all
    ]
Пример #10
0
def get_zero_crossing(audio):
    """
  Returns the sum of the zero crossings of the input audio
  inputs:
    - audio: the audio file
  outputs:
    - the sum of the zero crossings of audio
  """
    return sum(librosa.zero_crossings(audio, pad=False))
Пример #11
0
def synthesize(beats, piano_roll, fmin=0, bins_per_octave=12,
               tuning=0.0, wave=None, n=None):
    '''Synthesize a weighted piano roll'''

    # Quantize the piano roll
    sr = 22050

    piano_roll = quantize_values(piano_roll)

    if wave is None:
        wave = functools.partial(scipy.signal.square, duty=0.5)

    bins_per_semi = bins_per_octave/12
    first_bin = bins_per_semi/2

    frequencies = librosa.cqt_frequencies(n_bins=piano_roll.shape[0],
                                          fmin=fmin,
                                          bins_per_octave=bins_per_octave,
                                          tuning=tuning)

    beats -= beats[0]

    if n is None:
        n = beats[-1] + 0.5 * sr

    beats = librosa.util.fix_frames(beats, x_min=0, x_max=n)
    beat_intervals = librosa.util.frame(beats, frame_length=2, hop_length=1).T

    output = np.zeros(n)

    correction = 2.0 ** (tuning / bins_per_octave)
    stream = correction * 2.0 * np.pi * np.arange(len(output)) / sr

    active_bins = piano_roll.sum(axis=1) > 0

    for n, freq in enumerate(frequencies):
        if not active_bins[n * bins_per_semi + first_bin]:
            continue

        my_f = freq * stream

        sine = wave(my_f)

        # Align beat timings to zero crossings of sine
        zc_mask = librosa.zero_crossings(sine)

        beat_f = match_zc(beat_intervals, zc_mask, freq * correction, sr)

        # Mask out this frequency wherever it's inactive
        for m, (start, end) in enumerate(beat_f):
            sine[start:end] *= piano_roll[n*bins_per_semi + first_bin, m]

        output += sine

    output = librosa.util.normalize(output)
    return output, sr
Пример #12
0
 def cal_ZCR(self):
     n0 = 39000
     n1 = 39100
     plt.figure(figsize=(20, 5))
     plt.plot(self.x[n0:n1])
     plt.grid()
     plt.savefig('zcrPortion.png')
     plt.show()
     zero_crossings = librosa.zero_crossings(y=self.x[n0:n1], pad=False)
     return sum(zero_crossings)
Пример #13
0
def ZeroCrossings(x, sr):
    zero_crossings = librosa.zero_crossings(x, pad=False)
    print("zero crossings:", sum(zero_crossings))

    librosa.display.waveplot(x, sr=sr)
    plt.figure(figsize=(14, 5))
    plt.plot(x)
    if EXPORT_PNG:
        plt.savefig("zero_crossings.png")
    return zero_crossings
Пример #14
0
def get_zero_crossing_rate(x, sr):
    zerocrossing_temp = librosa.zero_crossings(x, pad=False)[:660000]
    # goal about 30k elements
    converted_array = [int(elem)
                       for elem in zerocrossing_temp]  # convert T/F to 1/0
    bumped_array = [elem * 10000 for elem in converted_array]
    flatten_zerocrossing = [
        np.mean(bumped_array[x:x + 5]) for x in range(0, len(bumped_array), 20)
    ]
    return flatten_zerocrossing
    def extract_feature_sound(cls, path):
        # Carrega o som
        x, sr = librosa.load(path)
        # Extrai a característica Zero Crossings e soma o resultado
        zero_crossing = sum(librosa.zero_crossings(x[9000:9100], pad=False))
        # Extrai a característica Spectral Centroid e soma o resultado
        spectral_centroids = sum(
            librosa.feature.spectral_centroid(x, sr=sr)[0])
        # Extrai a característica Spectral Rolloff e soma o resultado
        spectral_rolloff = sum(
            librosa.feature.spectral_rolloff(x + 0.01, sr=sr)[0])
        # Extrai a característica Mel Frequence - saida = array
        mel_spectrogram = librosa.feature.melspectrogram(x, sr=sr)
        # Soma os valores dos arrais em um unico valor e faz a média
        mel_spectrogram_count = 0
        for i in range(len(mel_spectrogram)):
            for j in range(len(mel_spectrogram[i])):
                mel_spectrogram_count = mel_spectrogram_count + \
                                        int(mel_spectrogram[i][j])
        mel_spectrogram_count = mel_spectrogram_count / len(mel_spectrogram)
        # Extrai a característica MFCC - saida = array
        mfcc = librosa.feature.mfcc(S=librosa.power_to_db(mel_spectrogram),
                                    sr=sr)
        # Soma os valores dos arrais em um unico valor e faz a média
        mfcc_count = 0
        for i in range(len(mfcc)):
            for j in range(len(mfcc[i])):
                mfcc_count = mfcc_count + int(mfcc[i][j])
        mfcc_count = mfcc_count / len(mfcc)
        # Extrai a característica Chroma STFT - saida = array
        chromagram = librosa.feature.chroma_stft(x, sr=sr, hop_length=512)
        # Soma os valores dos arrais em um unico valor e faz a média
        chromagram_count = 0
        for i in range(len(chromagram)):
            for j in range(len(chromagram[i])):
                chromagram_count = chromagram_count + int(chromagram[i][j])
        chromagram_count = chromagram_count / len(chromagram)

        # Segrega de quem é  a som
        character = "Gato"
        if path[20] == 'd':
            character = 'Cachorro'
        # Exibe o Caminho da Imagem no Console
        print('Caminho ', path)
        features = [
            int(zero_crossing),
            int(spectral_centroids),
            int(spectral_rolloff),
            int(mel_spectrogram_count),
            int(mfcc_count),
            int(chromagram_count),
            str(character)
        ]
        print('Características Extraidas', features)
        return features
Пример #16
0
def features(path):

    x, sr = librosa.load(path)
    tempo = librosa.beat.tempo(x, sr=sr)
    zero_crossings = sum(librosa.zero_crossings(x, pad=False))

    n_sb = librosa.util.normalize(
        librosa.feature.spectral_bandwidth(x, sr=sr)[0])
    spectral_bandwidth_mean = n_sb.mean()
    spectral_bandwidth_var = n_sb.var()

    n_sc = librosa.util.normalize(
        librosa.feature.spectral_contrast(x, sr=sr)[0])
    spectral_contrast_mean = n_sc.mean()
    spectral_contrast_var = n_sc.var()

    n_scc = librosa.util.normalize(
        librosa.feature.spectral_centroid(x, sr=sr)[0])
    spectral_centroids_mean = n_scc.mean()
    spectral_centroids_var = n_scc.var()

    n_sr = librosa.util.normalize(
        librosa.feature.spectral_rolloff(x, sr=sr)[0])
    spectral_rolloff_mean = n_sr.mean()
    spectral_rolloff_var = n_sr.var()

    n_sf = librosa.util.normalize(librosa.feature.spectral_flatness(x)[0])
    spectral_flatness_mean = n_sf.mean()
    spectral_flatness_var = n_sf.var()

    chroma_stft_mean, chroma_stft_var = mean_var_calculator(
        librosa.feature.chroma_stft(x, sr=sr))
    chroma_cqt_mean, chroma_cqt_var = mean_var_calculator(
        librosa.feature.chroma_cqt(x, sr=sr))
    chroma_cens_mean, chroma_cens_var = mean_var_calculator(
        librosa.feature.chroma_cens(x, sr=sr))
    mfcc_mean, mfcc_var = mean_var_calculator(librosa.feature.mfcc(x, sr=sr))

    features = [
        tempo[0], zero_crossings, spectral_bandwidth_mean,
        spectral_bandwidth_var, spectral_contrast_mean, spectral_contrast_var,
        spectral_centroids_mean, spectral_centroids_var, spectral_rolloff_mean,
        spectral_rolloff_var, spectral_flatness_mean, spectral_flatness_var
    ]
    features.extend(chroma_stft_mean)
    features.extend(chroma_stft_var)
    features.extend(chroma_cqt_mean)
    features.extend(chroma_cqt_var)
    features.extend(chroma_cens_mean)
    features.extend(chroma_cens_var)
    features.extend(mfcc_mean)
    features.extend(mfcc_var)

    return features
Пример #17
0
    def get_zero_crossing_rate(self, outside_series=None):
        """
        Return the number of times the signal changes sign

        :return: Integer
        """

        y = self.select_series(outside_series)

        zero_crossing = zero_crossings(y, pad=False)

        return sum(zero_crossing)
Пример #18
0
def zero_indexes(sample):
    """
    Create zero crossing indexes.
    We use these in synthesis, and it is easier to make them here.
    """
    zero_indexes = []
    for channel_index in range(sample.num_channels):
        channel = sample.get_all_audio_data()[channel_index]
        zero_crossings = librosa.zero_crossings(channel)
        zero_index = np.nonzero(zero_crossings)[0]
        zero_indexes.append(zero_index)
    return zero_indexes
Пример #19
0
    def get_zoomed_zero_crossing_rate(self, i, j):
        """
        Return number of time the signal changes sign in a range [i, j]

        :param i: start point
        :param j: end point
        :return: Integer
        """

        zero_crossing = zero_crossings(self.y[i:j], pad=False)

        return sum(zero_crossing)
Пример #20
0
 def _create_zero_indexes(self):
     """
     Create zero crossing indexes.
     We use these in synthesis, and it is easier to make them here.
     """
     zero_indexes = []
     for channel_index in range(self.num_channels):
         channel = self.raw_samples[channel_index]
         zero_crossings = librosa.zero_crossings(channel)
         zero_index = np.nonzero(zero_crossings)[0]
         zero_indexes.append(zero_index)
     return zero_indexes
Пример #21
0
def get_features(df):
    """Get features from sensor data
    For each sensor, peaks, promenences and periodograms features are computed.
        
    Parameters:
        df: pd.DataFrame
        Dataframe with 10 columns, corresponding to data from sensors
    Returns:
        features: list
        List with features
    """
    features = []
    # zeros_crossings
    features.extend(librosa.zero_crossings(df.values, axis=0).sum(axis=0))

    # find_peaks
    features.extend(df.apply(find_peaks, axis=0).iloc[0, :].apply(len).values)

    # peak_widths_max
    λ0 = lambda x: np.max(peak_widths(x,
                                      find_peaks(x)[0])[0]) if len(
                                          find_peaks(x)[0]) != 0 else 0
    features.extend(df.apply(λ0).values)

    # peak_widths_mean
    λ01 = lambda x: np.mean(peak_widths(x,
                                        find_peaks(x)[0])[0]) if len(
                                            find_peaks(x)[0]) != 0 else 0
    features.extend(df.apply(λ01).values)

    # peak_prominences_max
    λ1 = lambda x: np.max(peak_prominences(x,
                                           find_peaks(x)[0])[0]) if len(
                                               find_peaks(x)[0]) != 0 else 0
    features.extend(df.apply(λ1).values)

    # peak_prominences_mean
    λ11 = lambda x: np.mean(peak_prominences(x,
                                             find_peaks(x)[0])[0]) if len(
                                                 find_peaks(x)[0]) != 0 else 0
    features.extend(df.apply(λ11).values)

    # periodogram_max
    λ2 = lambda x: np.max(periodogram(x[~x.isna()], 100)[1]) if ~x.isna().all(
    ) else 0
    features.extend(np.sqrt(df.apply(λ2).values))  # Es un estimado del RMS

    # periodogram_mean
    λ3 = lambda x: np.mean(periodogram(x[~x.isna()], 100)[1]) if ~x.isna().all(
    ) else 0
    features.extend(df.apply(λ3).values)

    return features
Пример #22
0
 def _create_zero_indexes(self):
     """
     Create zero crossing indexes.
     We use these in synthesis, and it is easier to make them here.
     """
     zero_indexes = []
     for channel_index in range(self.num_channels):
         channel = self.raw_samples[channel_index]
         zero_crossings = librosa.zero_crossings(channel)
         zero_index = np.nonzero(zero_crossings)[0]
         zero_indexes.append(zero_index)
     return zero_indexes
Пример #23
0
def plot_zcr(y, smp_rate, row=3, col=1, idx=2, **kwargs):
    zcrs = rft.zero_crossing_rate(y,
                                  hop_length=_G.HopLen,
                                  frame_length=_G.ZCR_FrameLen,
                                  center=_G.ZCR_Center)
    plt.subplot(row, col, idx)
    plt.plot(zcrs[0])
    plt.xticks([])
    plt.xlim([0, _G.PLT_XLIM])
    # plt.title('Zero-crossing Rate')
    zcs = librosa.zero_crossings(y, pad=False)
    return zcrs
Пример #24
0
def get_windowed_zcr(data, block_length):
    num_blocks = int(np.ceil(len(data) / block_length))

    w_zcr = []

    for i in range(0, num_blocks):
        start = i * block_length
        stop = np.min([(start + block_length - 1), len(data)])

        zcr = lib.zero_crossings(data[start:stop])
        w_zcr.append(len(zcr))

    return np.asarray(w_zcr)
Пример #25
0
def extract_features(file, samp_type, features_arr):
    # get samples per second and sound data from the wav file
    sample_rate, signal = wav.read(file)
    if len(signal.shape
           ) == 2:  # if audio is two channeled we only take the first channel
        signal = signal.sum(axis=1) / 2

    # get data for FFT
    n = signal.shape[0]  # num of samples
    secs = n / float(sample_rate)  # time in seconds
    ts = 1.0 / sample_rate  # sampling interval (time)
    t = scipy.arange(
        0, secs, ts)  # gets equally spaced ticks over the sampling interval

    # perform FFT
    frequency = fft.fftfreq(signal.size, t[1] - t[0])
    amplitude = abs(scipy.fft(signal))

    if samp_type != -1:
        # getting amplitude near 22000 kHz
        index = 0
        # finding the index near 22 kHz and getting corresponding value in the amplitude array
        while frequency[index] < 21999.9:
            index += 1
            amp = amplitude[index]  # amplitude at 22kHz

    # getting number of frequencies above a threshold magnitude
    num_freq_above = 0
    threshold = 4000
    for i in amplitude:
        if i > threshold:
            num_freq_above += 1

    # getting file and loading in audio data
    file_path = file
    data, sr = librosa.load(file_path, sr=44100)

    # getting zero crossings
    zero_crossings = sum(librosa.zero_crossings(data, pad=False))

    # getting average decibels
    decibels = librosa.amplitude_to_db(data)
    avg_decibels = sum(decibels) / len(decibels)

    # checks if 22kHz feature should be included
    if samp_type == -1:
        features_arr.append([num_freq_above, zero_crossings, avg_decibels])
    else:
        features_arr.append(
            [amp, num_freq_above, zero_crossings, avg_decibels])
Пример #26
0
    def draw_f0_tu_tuong_quan(self, y_or, sr, window_len):
        duration = float(len(self.y_or)) / sr
        print("duration:", duration)
        print("yor", y_or)
        x = window_len
        time_ptr = []
        f0_list = []
        print("start draw ...")
        while x < duration - window_len * 1.01:
            # print("x: ", x)
            try:
                y_windows = y_or[int((x - window_len / 2) *
                                     sr):int((x + window_len / 2) * sr)]
                z = librosa.zero_crossings(y_windows)

                # print("zcr:", len(np.nonzero(z)[0]))
                N = len(y_windows)
                Xk = np.fft.fft(y_windows)
                E_fft = np.sum(np.abs(Xk)**2) / N
                # print("Efft: ",E_fft)
                if (len(np.nonzero(z)[0]) > 90) or (E_fft < 4):

                    f0_list.append(0)
                    time_ptr.append(x)
                    x += window_len / 2
                    continue
                    # return 0
                R_list = compute_arcf_list(y_windows, start=0, stop=301)
                d = diff(R_list)
                start = find(d > 0)[0]
                max_arcf_loc = argmax(R_list[start:]) + start
                R_second_list = R_list[(max_arcf_loc + 1):]
                d = diff(R_second_list)
                start = find(d > 0)[0]
                second_arcf_loc = argmax(R_second_list[start:]) + start
                # print(float(self.sr) / (second_arcf_loc))
                f0_list.append(float(self.sr) / (second_arcf_loc + 1))
                print("f0: ", float(self.sr) / (second_arcf_loc + 1))
                time_ptr.append(x)
                x += window_len / 2
            except Exception as e:
                print("loi ham draw_f0_tu_tuong_quan::: ", e)
                time_ptr.append(x)
                f0_list.append(0)
                x += window_len / 2
        average = np.average(f0_list)
        print(average, "; ", np.median(f0_list))
        self.ax3.set_ylim([0, 400])
        self.ax3.scatter(time_ptr, f0_list, s=2)
        pass
Пример #27
0
    def __test(data, threshold, ref_magnitude, pad, zp):

        zc = librosa.zero_crossings(y=data,
                                    threshold=threshold,
                                    ref_magnitude=ref_magnitude,
                                    pad=pad,
                                    zero_pos=zp)

        idx = np.flatnonzero(zc)

        if pad:
            idx = idx[1:]

        for i in idx:
            assert np.sign(data[i]) != np.sign(data[i-1])
Пример #28
0
    def __test(data, threshold, ref_magnitude, pad, zp):

        zc = librosa.zero_crossings(y=data,
                                    threshold=threshold,
                                    ref_magnitude=ref_magnitude,
                                    pad=pad,
                                    zero_pos=zp)

        idx = np.flatnonzero(zc)

        if pad:
            idx = idx[1:]

        for i in idx:
            assert np.sign(data[i]) != np.sign(data[i-1])
Пример #29
0
def load_audio(audio):
    list_ = []
    index = 0
    cols = ["mfkk" + str(i) for i in range(20)]
    for row in ["zero", "centroid", "rolloff", "chroma"]:
        cols.append(row)
    x, sr = librosa.load(os.path.join(app.config['UPLOAD_FOLDER'], audio),
                         duration=5,
                         res_type='kaiser_fast')
    list_.append([np.mean(x) for x in librosa.feature.mfcc(x, sr=sr)])
    list_[index].append(sum(librosa.zero_crossings(x)))
    list_[index].append(np.mean(librosa.feature.spectral_centroid(x)))
    list_[index].append(np.mean(librosa.feature.spectral_rolloff(x, sr=sr)))
    list_[index].append(np.mean(librosa.feature.chroma_stft(x, sr=sr)))
    return pd.DataFrame(list_, columns=cols)
Пример #30
0
def zeroCrossings(data: np.ndarray) -> int:
    """Count how many times the amplitude of the wave crosses
        the zero threshold.

    Parameters
    ----------
    data : np.ndarray
        Audio time series. [shape=(n,)]

    Returns
    -------
    int
        Hown many times the wave crossed zero.

    """
    return sum(lr.zero_crossings(data, pad=False))
Пример #31
0
 def get_FFT(self, audio):
     # x , sr = librosa.load(audio)
     x, sr = librosa.load(audio, sr=16000)
     zero_crossings = librosa.zero_crossings(x, pad=False)
     spectral_centroids = librosa.feature.spectral_centroid(x, sr=sr)[0]
     spectral_rolloff = librosa.feature.spectral_rolloff(x, sr=sr)[0]
     contrast = librosa.feature.spectral_contrast(x, sr=sr)
     bandwidth = librosa.feature.spectral_bandwidth(x, sr=sr)
     result = np.array([
         np.average(zero_crossings),
         np.average(spectral_centroids),
         np.average(spectral_rolloff),
         np.average(contrast),
         np.average(bandwidth)
     ])
     return result
Пример #32
0
 def plot_zero_crosing_rate(self):
     #Plot the signal:
     plt.figure(figsize=(14, 5))
     librosa.display.waveplot(self.data, sr=self.sampling_rate)
     # Zooming in
     tam = int(len(self.data) / 3)
     n0 = tam
     n1 = tam + 100
     print(">>>>>>>>>>>>>" + str(n1))
     plt.figure(figsize=(14, 5))
     plt.plot(self.data[n0:n1])
     plt.grid()
     plt.show()
     #
     zero_crossings = librosa.zero_crossings(self.data[n0:n1], pad=False)
     print(sum(zero_crossings))
Пример #33
0
def read_song_file(path):

    data, sample_rate = librosa.load(path)

    total_samples = np.size(data)
    #total_seconds = total_samples / sample_rate

    middle_samples = total_samples / 2

    #From position is 15 seconds before the middle
    from_pos = middle_samples - (15 * sample_rate)
    #To position is 15 seconds after the middle
    to_pos = middle_samples + (15 * sample_rate)

    #Extract data
    middle_data = data[int(from_pos):int(to_pos)]

    #Calculate the zero crossing rate
    zero_crossings = librosa.zero_crossings(y=middle_data, pad=False)
    zero_crossings = np.count_nonzero(zero_crossings)

    #Calculate the spectral centroid
    spectral_centroids = librosa.feature.spectral_centroid(y=middle_data,
                                                           sr=sample_rate)
    spectral_centroids.flatten()

    #Calculate the spectral rolloff
    spectral_rolloff = librosa.feature.spectral_rolloff(y=middle_data,
                                                        sr=sample_rate)
    spectral_rolloff.flatten()

    #Calculate mel-frequency cepstral coefficients
    mfccs = librosa.feature.mfcc(y=middle_data, sr=sample_rate)
    mfccs.flatten()

    #Calculate the chroma frequencies
    hop_length = 512
    chroma = librosa.feature.chroma_stft(y=middle_data,
                                         sr=sample_rate,
                                         hop_length=hop_length)
    chroma.flatten()

    end_data = np.concatenate(
        (spectral_centroids, spectral_rolloff, mfccs, chroma), axis=None)
    np.insert(end_data, 0, zero_crossings)

    return end_data
Пример #34
0
def classifier(rewrite=False):
    #file name, lang, zero_crossing_rate, spectral_centroid,
    #spectral_rolloff, Mel-Frequency_Cepstral_Coefficients\
    #chroma_frequencies
    if rewrite:
        columns = ['name', 'lang', 'zero_crossings', 'spectral_centroid', \
        'spectral_rolloff', 'mf1m', 'mf2m', 'mf3m', 'mf4m', 'mf5m', \
        'mf6m', 'mf7m', 'mf8m', 'mf9m', 'mf10m', 'mf11m', 'mf12m', \
        'mf13m', 'mf14m', 'mf15m', 'mf16m', 'mf17m', 'mf18m', 'mf19m', \
        'mf20m', 'mf1v', 'mf2v', 'mf3v', 'mf4v', 'mf5v', 'mf6v', 'mf7v', \
        'mf8v', 'mf9v', 'mf10v', 'mf11v', 'mf12v', 'mf13v', 'mf14v', \
        'mf15v', 'mf16v', 'mf17v', 'mf18v', 'mf19v', 'mf20v', 'cs1m', \
        'cs2m', 'cs3m', 'cs4m', 'cs5m', 'cs6m', 'cs7m', 'cs8m', 'cs9m', \
        'cs10m', 'cs11m', 'cs12m', 'cs1v', 'cs2v', 'cs3v', \
        'cs4v', 'cs5v', 'cs6v', 'cs7v', 'cs8v', 'cs9v', 'cs10v', \
        'cs11v', 'cs12v', 'label','genre']
        df = pd.DataFrame(columns=columns)
    else:
        df =  pd.read_csv('songs.csv')
    directory = 'library/'
    w = os.walk(directory)
    folders = next(w)[1]
    for folder in tqdm(folders,desc="Folders",leave=False):
        songs = os.listdir(directory+folder)
        for song_name in tqdm(songs,desc="Songs",leave=False):
            if not song_name in list(df['name']):
                new_row = []
                new_row.append(song_name)
                new_row.append(langdetect.detect(song_name))
                song, sr = librosa.load(directory+folder+'/'+song_name)
                new_row.append(np.mean(librosa.zero_crossings(song)))
                new_row.append(np.mean(librosa.feature.spectral_centroid(song, sr=sr)[0]))
                new_row.append(np.mean(librosa.feature.spectral_rolloff(song+0.01, sr=sr)[0]))
                new_row = new_row + list(librosa.feature.mfcc(song, sr=sr).mean(axis=1))
                new_row = new_row + list(librosa.feature.mfcc(song, sr=sr).var(axis=1))
                new_row = new_row + list(librosa.feature.chroma_stft(song, sr=sr).mean(axis=1))
                new_row = new_row + list(librosa.feature.chroma_stft(song, sr=sr).var(axis=1))
                if folder == 'rotation':
                    new_row.append(-1)
                else:
                    new_row.append(int(folder.split('_')[0]))
                new_row.append('[]')
                df.loc[df.index.max()+1] = new_row
                df.to_csv('songs.csv',index=False)    
Пример #35
0
def test_zero_indexes():
    channel = mono_audio.raw_samples[0]
    zero_crossings = librosa.zero_crossings(channel)
    zero_index = np.nonzero(zero_crossings)[0]
    assert(mono_audio.zero_indexes[0].all() == zero_index.all())
Пример #36
0
def crossfade(audio1, audio2, slices):
    """ 
    Apply crossfading to 2 audio tracks. The fade function is randomly applied
    :param audio1: your first signal 
    :param audio2: your second signal
    :param slices: slices of intervals                                                                            
    :returns:                                                                                                         
      - crossfaded audio
    """
    def fade_out(audio):  
        dbs = 20 * np.log10(abs(audio))
        thres = max(dbs)             
        db_steps = np.arange(abs(thres), 120)
        start = 0
        try:
            sections = int(len(dbs)/len(db_steps))
        except Exception as e:
            return audio
        i = 0                            
        while (start + len(db_steps)) < len(dbs):
            dbs[start:sections + start] -= db_steps[i]
            start += sections
            i += 1 
        if dbs.argmin() == 0:
            dbs = dbs[::-1]
        faded = 10 ** (dbs * 0.05)
        faded[audio < 0] *= -1  
        return faded
    def fade_in(audio):  
        dbs = 20 * np.log10(abs(audio))
        try:
            thres = max(dbs)
        except Exception as e:
            return audio
        dbs = dbs[::-1]            
        db_steps = np.arange(abs(thres), 120)
        start = 0
        try:
            sections = int(len(dbs)/len(db_steps))
        except Exception as e:
            return audio
        i = 0                            
        while (start + len(db_steps)) < len(dbs):
            dbs[start:sections + start] -= db_steps[i]
            start += sections
            i += 1  
        if dbs.argmin() != 0:
            dbs = dbs[::-1]
        faded = 10 ** (dbs * 0.05) 
        faded[audio < 0] *= -1  
        return  faded 
    amp1 = np.nonzero(librosa.zero_crossings(audio1))[-1]
    amp2 = np.nonzero(librosa.zero_crossings(audio2))[-1] 
    amp1 = amp1[librosa.util.match_events(slices[0], amp1)]
    amp2 = amp2[librosa.util.match_events(slices[1], amp2)]
    a = []
    for i in range(len(amp1)):
        a.append(list(audio1[slice(amp1[i][0], amp1[i][1])]))
    a_rev = []
    for i in range(len(amp2)):
        a_rev.append(list(audio2[slice(amp2[i][0], amp2[i][1])]))
    if choice([0,1]) == 0:
        amp1=  fade_out(np.concatenate(a))
        amp2=  fade_in(np.concatenate(a_rev))
    else:
        amp2 = fade_in(np.concatenate(a_rev))
        amp1 = fade_out(np.concatenate(a))
    size = min([len(amp1), len(amp2)])
    result = amp1[:size] + amp2[:size] 
    return 0.5 * result / result.max()