def plot_static_beat(tempo, onset_env, sampling_rate): # Convert to scalar tempo = np.asscalar(tempo) # Compute 2-second windowed autocorrelation hop_length = 512 auto_correlation = librosa.autocorrelate(onset_env, 2 * sampling_rate // hop_length) freqs = librosa.tempo_frequencies(len(auto_correlation), sr=sampling_rate, hop_length=hop_length) # Plot on a BPM axis. We skip the first (0-lag) bin. fig = plt.figure(figsize=(8, 4)) ax = fig.add_subplot(111) ax.semilogx(freqs[1:], librosa.util.normalize(auto_correlation)[1:], label='Onset autocorrelation', basex=2) ax.axvline(tempo, 0, 1, color='r', alpha=0.75, linestyle='--', label='Tempo: {:.2f} BPM'.format(tempo)) ax.grid() ax.axis('tight') return fig
def getVisualTempogram(self, window_length=None, force_recompute=None, norm_columns=None, **kwargs): """ :param self: :param window_length: in seconds :param force_recompute: :param kwargs: :return: """ feature_name = 'visual_tempogram'; if ((not self.hasFeature(feature_name)) or force_recompute): if (window_length is None): window_length = DEFAULT_TEMPOGRAM_WINDOW_SECONDS; params = kwargs; params.update({'force_recompute': force_recompute}); vbe = self.computeImpactEnvelope(cut_suppression_seconds=None); onset_envelope = vbe; win_length = int(round(window_length * self.sampling_rate)); sr = self.sampling_rate; hop_length = 1; center = kwargs.get('center'); if (center is None): center = True; window = 'hann' norm = np.inf; ac_window = librosa.filters.get_window(window, win_length, fftbins=True) # Center the autocorrelation windows n = len(onset_envelope) if center: onset_envelope = np.pad(onset_envelope, int(win_length // 2), mode='linear_ramp', end_values=[0, 0]) # Carve onset envelope into frames odf_frame = librosa.util.frame(onset_envelope, frame_length=win_length, hop_length=hop_length) # Truncate to the length of the original signal if center: odf_frame = odf_frame[:, :n] odf_frame = librosa.util.normalize(odf_frame, axis=0, norm=norm) if (norm_columns is None): norm_columns = True; if (norm_columns): # Window, autocorrelate, and normalize result = librosa.util.normalize( librosa.core.audio.autocorrelate(odf_frame * ac_window[:, np.newaxis], axis=0), norm=norm, axis=0); else: result = librosa.core.audio.autocorrelate(odf_frame * ac_window[:, np.newaxis], axis=0); result = np.true_divide(result, np.max(result.ravel())); tempo_bpms = librosa.tempo_frequencies(result.shape[0], hop_length=hop_length, sr=sr) self.setFeature(name='tempogram_bpms', value=tempo_bpms); ########### self.setFeature(name=feature_name, value=result, params=params); return self.getFeature(feature_name);
def plot_correlation1(self, onset_env, sr): hop_length = 512 ac = librosa.autocorrelate(onset_env, 2 * sr // hop_length) freqs = librosa.tempo_frequencies(len(ac), sr=sr, hop_length=hop_length) self.li.set_xdata(freqs[1:]) self.li.set_ydata(librosa.util.normalize(ac)[1:]) plt.pause(0.001)
def getTempogram(self, window_length=None, force_recompute=None, frame_rate=None, resample_rate=None, **kwargs): """ :param self: :param window_length: in seconds :param force_recompute: :param kwargs: :return: """ feature_name = 'tempogram' if ((not self.hasFeature(feature_name)) or force_recompute): if (window_length is None): window_length = DEFAULT_TEMPOGRAM_WINDOW_SECONDS tpgparams = {} tpgparams.update(kwargs) sr = self.sampling_rate y = self.getSignal() if (resample_rate is None): resample_rate = 22050 if (sr > resample_rate): print(("resampling {}Hz to {}Hz".format(sr, resample_rate))) y = librosa.core.resample(y, orig_sr=sr, target_sr=resample_rate) sr = resample_rate print("resampled") if (frame_rate is None): frame_rate = 30 hop_length = int(round(truediv(sr, frame_rate))) win_length = int(round(window_length * frame_rate)) tparams = dict(y=y, sr=sr, hop_length=hop_length, win_length=win_length, **kwargs) tpgparams.update( dict(sr=sr, hop_length=hop_length, win_length=win_length)) result = librosa.feature.tempogram(**tparams) ########### tempo_bpms = librosa.tempo_frequencies(result.shape[0], hop_length=hop_length, sr=sr) self.setFeature(name='tempogram_bpms', value=tempo_bpms) self.setFeature(name=feature_name, value=result, params=tpgparams) self.setInfo(label='tempogram_params', value=tpgparams) return self.getFeature(feature_name)
def __test(n_bins, hop_length, sr): freqs = librosa.tempo_frequencies(n_bins, hop_length=hop_length, sr=sr) # Verify the length assert len(freqs) == n_bins # 0-bin should be infinite assert not np.isfinite(freqs[0]) # remaining bins should be spaced by 1/hop_length if n_bins > 1: invdiff = (freqs[1:]**-1) * (60.0 * sr) assert np.allclose(invdiff[0], hop_length) assert np.allclose(np.diff(invdiff), np.asarray(hop_length)), np.diff(invdiff)
def __test(n_bins, hop_length, sr): freqs = librosa.tempo_frequencies(n_bins, hop_length=hop_length, sr=sr) # Verify the length eq_(len(freqs), n_bins) # 0-bin should be infinite assert not np.isfinite(freqs[0]) # remaining bins should be spaced by 1/hop_length if n_bins > 1: invdiff = (freqs[1:]**-1) * (60.0 * sr) assert np.allclose(invdiff[0], hop_length) assert np.allclose(np.diff(invdiff), np.asarray(hop_length)), np.diff(invdiff)
def tempoVSautoCorrelation(tempo, hop_length): tempo = np.asscalar(tempo) ac = librosa.autocorrelate(onset_env, 2 * sr // hop_length) freqs = librosa.tempo_frequencies(len(ac), sr=sr, hop_length=hop_length) plt.figure(figsize=(8, 4)) plt.semilogx(freqs[1:], librosa.util.normalize(ac)[1:], label='Onset autocorrelation', basex=2) plt.axvline(tempo, 0, 1, color='r', alpha=0.75, linestyle='--', label='Tempo: {:.2f} BPM'.format(tempo)) plt.xlabel('Tempo (BPM)') plt.grid() plt.title('Static tempo estimation') plt.legend(frameon=True) plt.axis('tight')
def ac_peaks(data, rate, plot=False): """Return the three highest peaks in the autocorrelation (tempo) array. Plot if needed.""" # Get the onset strength envelope (deals with lag, spectral flux, but the main idea is that it can give us info about lag/variation in the audio, so we can use it to get tempo information) oenv = librosa.onset.onset_strength(y=data, sr=rate) # Compute the tempogram and truncate at time (index) 1000 gram = tempogram(data, rate) gram = gram[:, :1000] # Get the global autocorrelation and the frequencies (in this case, freqs indicate BPM estimates) ac_global = librosa.autocorrelate(oenv, max_size=gram.shape[0]) freqs = librosa.tempo_frequencies(gram.shape[0], sr=rate) # Find the peaks of the autocorrelation plot, sort them, and keep only the three highest peaks peaks, _ = find_peaks(ac_global) sorting = np.argsort(ac_global[peaks]) peaks = peaks[sorting][-3:] # Plot the stuff if requested if plot: plt.semilogx(freqs, ac_global, ':', base=2) plt.semilogx(freqs[peaks], ac_global[peaks], marker='o', linestyle='', base=2) plt.xlabel('BPM') plt.ylabel('Autocorrelation') plt.legend(['Global Autocorrelation', 'Three Highest Peaks']) plt.show() # Return the frequencies with the three highest autocorrelation value as an array if len(freqs[peaks]) == 3: return np.array(freqs[peaks])[::-1] else: return np.array([float('NaN'), float('NaN'), float('NaN')])
import numpy as np import matplotlib.pyplot as plt from glob import glob import librosa as lr audio = 'arabic6' y, sr = lr.load('./{}.wav'.format(audio)) onset_env = lr.onset.onset_strength(y, sr=sr) tempo = lr.beat.tempo(onset_envelope=onset_env, sr=sr) print(tempo) tempo = np.asscalar(tempo) # Compute 2-second windowed autocorrelation hop_length = 512 ac = lr.autocorrelate(onset_env, 2 * sr // hop_length) freqs = lr.tempo_frequencies(len(ac), sr=sr, hop_length=hop_length) # Plot on a BPM axis. We skip the first (0-lag) bin. plt.figure(figsize=(8, 4)) plt.semilogx(freqs[1:], lr.util.normalize(ac)[1:], label='Onset autocorrelation', basex=2) plt.axvline(tempo, 0, 1, color='r', alpha=0.75, linestyle='--', label='Tempo: {:.2f} BPM'.format(tempo)) plt.xlabel('Tempo (BPM)') plt.grid() plt.title('Static tempo estimation')
label='Estimated tempo={:g}'.format(tempo)) plt.legend(frameon=True, framealpha=0.75) plt.subplot(4, 1, 3) x = np.linspace(0, tempogram.shape[0] * float(hop_length) / sr, num=tempogram.shape[0]) plt.plot(x, np.mean(tempogram, axis=1), label='Mean local autocorrelation') plt.plot(x, ac_global, '--', alpha=0.75, label='Global autocorrelation') plt.xlabel('Lag (seconds)') plt.axis('tight') plt.legend(frameon=True) plt.subplot(4, 1, 4) # We can also plot on a BPM axis freqs = librosa.tempo_frequencies(tempogram.shape[0], hop_length=hop_length, sr=sr) plt.semilogx(freqs[1:], np.mean(tempogram[1:], axis=1), label='Mean local autocorrelation', basex=2) plt.semilogx(freqs[1:], ac_global[1:], '--', alpha=0.75, label='Global autocorrelation', basex=2) plt.axvline(tempo, color='black', linestyle='--', alpha=.8,
def plot_tempogram(number): example_mp3, sr, song_name = load_music.load_song(number) hop_length = 512 oenv = librosa.onset.onset_strength(y=example_mp3, sr=sr, hop_length=hop_length) tempogram = librosa.feature.tempogram(onset_envelope=oenv, sr=sr, hop_length=hop_length) # Compute global onset autocorrelation ac_global = librosa.autocorrelate(oenv, max_size=tempogram.shape[0]) ac_global = librosa.util.normalize(ac_global) # Estimate the global tempo for display purposes tempo = librosa.beat.tempo(onset_envelope=oenv, sr=sr, hop_length=hop_length)[0] fig, ax = plt.subplots(nrows=4, figsize=(10, 10)) times = librosa.times_like(oenv, sr=sr, hop_length=hop_length) ax[0].plot(times, oenv, label='Onset strength') ax[0].label_outer() ax[0].legend(frameon=True) librosa.display.specshow(tempogram, sr=sr, hop_length=hop_length, x_axis='time', y_axis='tempo', cmap='magma', ax=ax[1]) ax[1].axhline(tempo, color='w', linestyle='--', alpha=1, label='Estimated tempo={:g}'.format(tempo)) ax[1].legend(loc='upper right') ax[1].set(title='Tempogram') x = np.linspace(0, tempogram.shape[0] * float(hop_length) / sr, num=tempogram.shape[0]) ax[2].plot(x, np.mean(tempogram, axis=1), label='Mean local autocorrelation') ax[2].plot(x, ac_global, '--', alpha=0.75, label='Global autocorrelation') ax[2].set(xlabel='Lag (seconds)') ax[2].legend(frameon=True) freqs = librosa.tempo_frequencies(tempogram.shape[0], hop_length=hop_length, sr=sr) ax[3].semilogx(freqs[1:], np.mean(tempogram[1:], axis=1), label='Mean local autocorrelation', basex=2) ax[3].semilogx(freqs[1:], ac_global[1:], '--', alpha=0.75, label='Global autocorrelation', basex=2) ax[3].axvline(tempo, color='black', linestyle='--', alpha=.8, label='Estimated tempo={:g}'.format(tempo)) ax[3].legend(frameon=True) ax[3].set(xlabel='BPM') ax[3].grid(True) fig.suptitle('Tempogram on ' + song_name, fontsize=8) plt.show()
def Tempogram_Show2(self, show=True): hop_length = 512 tempogram_record = librosa.feature.tempogram( onset_envelope=self.__onset_env_record, sr=self.__sr_record, hop_length=hop_length) tempo_record = librosa.beat.tempo( onset_envelope=self.__onset_env_record, sr=self.__sr_record, hop_length=hop_length)[0] ac_global_record = librosa.autocorrelate( self.__onset_env_record, max_size=tempogram_record.shape[0]) ac_global_record = librosa.util.normalize(ac_global_record) x_record = np.linspace(0, tempogram_record.shape[0] * float(hop_length) / self.__sr_record, num=tempogram_record.shape[0]) tempogram_music = librosa.feature.tempogram( onset_envelope=self.__onset_env_music, sr=self.__sr_music, hop_length=hop_length) tempo_music = librosa.beat.tempo(onset_envelope=self.__onset_env_music, sr=self.__sr_music, hop_length=hop_length)[0] ac_global_music = librosa.autocorrelate( self.__onset_env_music, max_size=tempogram_music.shape[0]) ac_global_music = librosa.util.normalize(ac_global_music) x_music = np.linspace(0, tempogram_music.shape[0] * float(hop_length) / self.__sr_music, num=tempogram_music.shape[0]) if show == True: fig, ax = plt.subplots(nrows=4) plt.title('Recording:') ax[0].plot(x_record, np.mean(tempogram_record, axis=1), label='Mean local autocorrelation') ax[0].plot(x_record, ac_global_record, '--', alpha=0.75, label='Global autocorrelation') ax[0].set(xlabel='Record Lag (seconds)') ax[0].legend(title='Recording:', frameon=True) ax[1].plot(x_music, np.mean(tempogram_music, axis=1), label='Mean local autocorrelation') ax[1].plot(x_music, ac_global_music, '--', alpha=0.75, label='Global autocorrelation') ax[1].set(xlabel='Music Lag (seconds)') ax[1].legend(title='Music:', frameon=True) freqs_record = librosa.tempo_frequencies(tempogram_record.shape[0], hop_length=hop_length, sr=self.__sr_record) freqs_music = librosa.tempo_frequencies(tempogram_music.shape[0], hop_length=hop_length, sr=self.__sr_music) ax[2].semilogx(freqs_record[1:], np.mean(tempogram_record[1:], axis=1), label='Mean local autocorrelation', basex=2) ax[2].semilogx(freqs_record[1:], ac_global_record[1:], '--', alpha=0.75, label='Global autocorrelation', basex=2) ax[2].axvline(tempo_record, color='black', linestyle='--', alpha=.8, label='Estimated tempo={:g}'.format(tempo_record)) ax[2].legend(title='Recording:', frameon=True) ax[2].set(xlabel='BPM') ax[2].grid(True) ax[3].semilogx(freqs_music[1:], np.mean(tempogram_music[1:], axis=1), label='Mean local autocorrelation', basex=2) ax[3].semilogx(freqs_music[1:], ac_global_music[1:], '--', alpha=0.75, label='Global autocorrelation', basex=2) ax[3].axvline(tempo_music, color='black', linestyle='--', alpha=.8, label='Estimated tempo={:g}'.format(tempo_music)) ax[3].legend(title='Music:', frameon=True) ax[3].set(xlabel='BPM') ax[3].grid(True) plt.show() return format(tempo_music), format(tempo_record)
def Tempogram_Show(self): tempogram = librosa.feature.tempogram(onset_envelope=self.__onset_env, sr=self.__sr, hop_length=self.__hop_length) ac_global = librosa.autocorrelate(self.__onset_env, max_size=tempogram.shape[0]) ac_global = librosa.util.normalize(ac_global) tempo = librosa.beat.tempo(onset_envelope=self.__onset_env, sr=self.__sr, hop_length=self.__hop_length)[0] fig, ax = plt.subplots(nrows=4, figsize=(10, 10)) times = librosa.times_like(self.__onset_env, sr=self.__sr, hop_length=self.__hop_length) ax[0].plot(times, self.__onset_env, label='Onset strength') ax[0].label_outer() ax[0].legend(frameon=True) librosa.display.specshow(tempogram, sr=self.__sr, hop_length=self.__hop_length, x_axis='time', y_axis='tempo', cmap='magma', ax=ax[1]) ax[1].axhline(tempo, color='w', linestyle='--', alpha=1, label='Estimated tempo={:g}'.format(tempo)) ax[1].legend(loc='upper right') ax[1].set(title='Tempogram') x = np.linspace(0, tempogram.shape[0] * float(self.__hop_length) / self.__sr, num=tempogram.shape[0]) ax[2].plot(x, np.mean(tempogram, axis=1), label='Mean local autocorrelation') ax[2].plot(x, ac_global, '--', alpha=0.75, label='Global autocorrelation') ax[2].set(xlabel='Lag (seconds)') ax[2].legend(frameon=True) freqs = librosa.tempo_frequencies(tempogram.shape[0], hop_length=self.__hop_length, sr=self.__sr) ax[3].semilogx(freqs[1:], np.mean(tempogram[1:], axis=1), label='Mean local autocorrelation', basex=2) ax[3].semilogx(freqs[1:], ac_global[1:], '--', alpha=0.75, label='Global autocorrelation', basex=2) ax[3].axvline(tempo, color='black', linestyle='--', alpha=.8, label='Estimated tempo={:g}'.format(tempo)) ax[3].legend(frameon=True) ax[3].set(xlabel='BPM') ax[3].grid(True) plt.show()