Madmom documentation¶

madmom.audio.signal¶

This module contains basic signal processing functionality.

madmom.audio.signal.smooth(signal, kernel)[source]¶

Smooth the signal along its first axis.

Parameters:	signal : numpy array Signal to be smoothed. kernel : numpy array or int Smoothing kernel (size).
Returns:	numpy array Smoothed signal.

Notes

If kernel is an integer, a Hamming window of that length will be used as a smoothing kernel.

madmom.audio.signal.adjust_gain(signal, gain)[source]¶

” Adjust the gain of the signal.

Parameters:	signal : numpy array Signal to be adjusted. gain : float Gain adjustment level [dB].
Returns:	numpy array Signal with adjusted gain.

Notes

The signal is returned with the same dtype, thus rounding errors may occur with integer dtypes.

gain values > 0 amplify the signal and are only supported for signals with float dtype to prevent clipping and integer overflows.

madmom.audio.signal.attenuate(signal, attenuation)[source]¶

Attenuate the signal.

Parameters:	signal : numpy array Signal to be attenuated. attenuation : float Attenuation level [dB].
Returns:	numpy array Attenuated signal (same dtype as signal).

Notes

The signal is returned with the same dtype, thus rounding errors may occur with integer dtypes.

madmom.audio.signal.normalize(signal)[source]¶

Normalize the signal to have maximum amplitude.

Parameters:	signal : numpy array Signal to be normalized.
Returns:	numpy array Normalized signal.

Notes

Signals with float dtypes cover the range [-1, +1], signals with integer dtypes will cover the maximally possible range, e.g. [-32768, 32767] for np.int16.

The signal is returned with the same dtype, thus rounding errors may occur with integer dtypes.

madmom.audio.signal.remix(signal, num_channels)[source]¶

Remix the signal to have the desired number of channels.

Parameters:	signal : numpy array Signal to be remixed. num_channels : int Number of channels.
Returns:	numpy array Remixed signal (same dtype as signal).

Notes

This function does not support arbitrary channel number conversions. Only down-mixing to and up-mixing from mono signals is supported.

The signal is returned with the same dtype, thus rounding errors may occur with integer dtypes.

If the signal should be down-mixed to mono and has an integer dtype, it will be converted to float internally and then back to the original dtype to prevent clipping of the signal. To avoid this double conversion, convert the dtype first.

madmom.audio.signal.rescale(signal, dtype=<type 'numpy.float32'>)[source]¶

Rescale the signal to range [-1, 1] and return as float dtype.

Parameters:	signal : numpy array Signal to be remixed. dtype : numpy dtype Data type of the signal.
Returns:	numpy array Signal rescaled to range [-1, 1].

madmom.audio.signal.trim(signal, where='fb')[source]¶

Trim leading and trailing zeros of the signal.

Parameters:	signal : numpy array Signal to be trimmed. where : str, optional A string with ‘f’ representing trim from front and ‘b’ to trim from back. Default is ‘fb’, trim zeros from both ends of the signal.
Returns:	numpy array Trimmed signal.

madmom.audio.signal.root_mean_square(signal)[source]¶

Computes the root mean square of the signal. This can be used as a measurement of power.

Parameters:	signal : numpy array Signal.
Returns:	rms : float Root mean square of the signal.

madmom.audio.signal.sound_pressure_level(signal, p_ref=None)[source]¶

Computes the sound pressure level of a signal.

Parameters:	signal : numpy array Signal. p_ref : float, optional Reference sound pressure level; if ‘None’, take the max amplitude value for the data-type, if the data-type is float, assume amplitudes are between -1 and +1.
Returns:	spl : float Sound pressure level of the signal [dB].

Notes

From http://en.wikipedia.org/wiki/Sound_pressure: Sound pressure level (SPL) or sound level is a logarithmic measure of the effective sound pressure of a sound relative to a reference value. It is measured in decibels (dB) above a standard reference level.

madmom.audio.signal.load_wave_file(filename, sample_rate=None, num_channels=None, start=None, stop=None, dtype=None)[source]¶

Load the audio data from the given file and return it as a numpy array.

Only supports wave files, does not support re-sampling or arbitrary channel number conversions. Reads the data as a memory-mapped file with copy-on-write semantics to defer I/O costs until needed.

Parameters:

filename : str Name of the file. sample_rate : int, optional Desired sample rate of the signal [Hz], or ‘None’ to return the signal in its original rate. num_channels : int, optional Reduce or expand the signal to num_channels channels, or ‘None’ to return the signal with its original channels. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. dtype : numpy data type, optional The data is returned with the given dtype. If ‘None’, it is returned with its original dtype, otherwise the signal gets rescaled. Integer dtypes use the complete value range, float dtypes the range [-1, +1].

Returns:

signal : numpy array Audio signal. sample_rate : int Sample rate of the signal [Hz].

Notes

The start and stop positions are rounded to the closest sample; the sample corresponding to the stop value is not returned, thus consecutive segment starting with the previous stop can be concatenated to obtain the original signal without gaps or overlaps.

exception madmom.audio.signal.LoadAudioFileError(value=None)[source]¶

Exception to be raised whenever an audio file could not be loaded.

madmom.audio.signal.load_audio_file(filename, sample_rate=None, num_channels=None, start=None, stop=None, dtype=None)[source]¶

Load the audio data from the given file and return it as a numpy array. This tries load_wave_file() load_ffmpeg_file() (for ffmpeg and avconv).

Parameters:

filename : str or file handle Name of the file or file handle. sample_rate : int, optional Desired sample rate of the signal [Hz], or ‘None’ to return the signal in its original rate. num_channels: int, optional Reduce or expand the signal to num_channels channels, or ‘None’ to return the signal with its original channels. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. dtype : numpy data type, optional The data is returned with the given dtype. If ‘None’, it is returned with its original dtype, otherwise the signal gets rescaled. Integer dtypes use the complete value range, float dtypes the range [-1, +1].

Returns:

signal : numpy array Audio signal. sample_rate : int Sample rate of the signal [Hz].

Notes

For wave files, the start and stop positions are rounded to the closest sample; the sample corresponding to the stop value is not returned, thus consecutive segment starting with the previous stop can be concatenated to obtain the original signal without gaps or overlaps. For all other audio files, this can not be guaranteed.

class madmom.audio.signal.Signal(data, sample_rate=None, num_channels=None, start=None, stop=None, norm=False, gain=0.0, dtype=None)[source]¶

The Signal class represents a signal as a (memory-mapped) numpy array and enhances it with a number of attributes.

Parameters:

data : numpy array, str or file handle Signal data or file name or file handle. sample_rate : int, optional Desired sample rate of the signal [Hz], or ‘None’ to return the signal in its original rate. num_channels : int, optional Reduce or expand the signal to num_channels channels, or ‘None’ to return the signal with its original channels. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. norm : bool, optional Normalize the signal to maximum range of the data type. gain : float, optional Adjust the gain of the signal [dB]. dtype : numpy data type, optional The data is returned with the given dtype. If ‘None’, it is returned with its original dtype, otherwise the signal gets rescaled. Integer dtypes use the complete value range, float dtypes the range [-1, +1].

Notes

sample_rate or num_channels can be used to set the desired sample rate and number of channels if the audio is read from file. If set to ‘None’ the audio signal is used as is, i.e. the sample rate and number of channels are determined directly from the audio file.

If the data is a numpy array, the sample_rate is set to the given value and num_channels is set to the number of columns of the array.

The gain can be used to adjust the level of the signal.

If both norm and gain are set, the signal is first normalized and then the gain is applied afterwards.

If norm or gain is set, the selected part of the signal is loaded into memory completely, i.e. .wav files are not memory-mapped any more.

Examples

Load a mono audio file:

>>> sig = Signal('tests/data/audio/sample.wav')
>>> sig
Signal([-2494, -2510, ...,   655,   639], dtype=int16)
>>> sig.sample_rate
44100

Load a stereo audio file, down-mix it to mono:

>>> sig = Signal('tests/data/audio/stereo_sample.flac', num_channels=1)
>>> sig
Signal([ 36,  36, ..., 524, 495], dtype=int16)
>>> sig.num_channels
1

Load and re-sample an audio file:

>>> sig = Signal('tests/data/audio/sample.wav', sample_rate=22050)
>>> sig
Signal([-2470, -2553, ...,   517,   677], dtype=int16)
>>> sig.sample_rate
22050

Load an audio file with float32 data type (i.e. rescale it to [-1, 1]):

>>> sig = Signal('tests/data/audio/sample.wav', dtype=np.float32)
>>> sig
Signal([-0.07611, -0.0766 , ...,  0.01999,  0.0195 ], dtype=float32)
>>> sig.dtype
dtype('float32')

num_samples¶

Number of samples.

num_channels¶

Number of channels.

length¶

Length of signal in seconds.

class madmom.audio.signal.SignalProcessor(sample_rate=None, num_channels=None, start=None, stop=None, norm=False, gain=0.0, **kwargs)[source]¶

The SignalProcessor class is a basic signal processor.

Parameters:

sample_rate : int, optional Sample rate of the signal [Hz]; if set the signal will be re-sampled to that sample rate; if ‘None’ the sample rate of the audio file will be used. num_channels : int, optional Number of channels of the signal; if set, the signal will be reduced to that number of channels; if ‘None’ as many channels as present in the audio file are returned. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. norm : bool, optional Normalize the signal to the range [-1, +1]. gain : float, optional Adjust the gain of the signal [dB]. dtype : numpy data type, optional The data is returned with the given dtype. If ‘None’, it is returned with its original dtype, otherwise the signal gets rescaled. Integer dtypes use the complete value range, float dtypes the range [-1, +1].

Examples

Processor for loading the first two seconds of an audio file, re-sampling it to 22.05 kHz and down-mixing it to mono:

>>> proc = SignalProcessor(sample_rate=22050, num_channels=1, stop=2)
>>> sig = proc('tests/data/audio/sample.wav')
>>> sig
Signal([-2470, -2553, ...,  -173,  -265], dtype=int16)
>>> sig.sample_rate
22050
>>> sig.num_channels
1
>>> sig.length
2.0

process(data, start=None, stop=None, **kwargs)[source]¶

Processes the given audio file.

Parameters:	data : numpy array, str or file handle Data to be processed. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds].
Returns:	signal : Signal instance Signal instance.

static add_arguments(parser, sample_rate=None, mono=None, start=None, stop=None, norm=None, gain=None)[source]¶

Add signal processing related arguments to an existing parser.

Parameters:

parser : argparse parser instance Existing argparse parser object. sample_rate : int, optional Re-sample the signal to this sample rate [Hz]. mono : bool, optional Down-mix the signal to mono. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. norm : bool, optional Normalize the signal to the range [-1, +1]. gain : float, optional Adjust the gain of the signal [dB].

Returns:

argparse argument group Signal processing argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’. To include start and stop arguments with a default value of ‘None’, i.e. do not set any start or stop time, they can be set to ‘True’.

madmom.audio.signal.signal_frame(signal, index, frame_size, hop_size, origin=0)[source]¶

This function returns frame at index of the signal.

Parameters:	signal : numpy array Signal. index : int Index of the frame to return. frame_size : int Size of each frame in samples. hop_size : float Hop size in samples between adjacent frames. origin : int Location of the window center relative to the signal position.
Returns:	frame : numpy array Requested frame of the signal.

Notes

The reference sample of the first frame (index == 0) refers to the first sample of the signal, and each following frame is placed hop_size samples after the previous one.

The window is always centered around this reference sample. Its location relative to the reference sample can be set with the origin parameter. Arbitrary integer values can be given:

• zero centers the window on its reference sample
• negative values shift the window to the right
• positive values shift the window to the left

An origin of half the size of the frame_size results in windows located to the left of the reference sample, i.e. the first frame starts at the first sample of the signal.

The part of the frame which is not covered by the signal is padded with zeros.

This function is totally independent of the length of the signal. Thus, contrary to common indexing, the index ‘-1’ refers NOT to the last frame of the signal, but instead the frame left of the first frame is returned.

class madmom.audio.signal.FramedSignal(signal, frame_size=2048, hop_size=441.0, fps=None, origin=0, end='normal', num_frames=None, **kwargs)[source]¶

The FramedSignal splits a Signal into frames and makes it iterable and indexable.

Parameters:

signal : Signal instance Signal to be split into frames. frame_size : int, optional Size of one frame [samples]. hop_size : float, optional Progress hop_size samples between adjacent frames. fps : float, optional Use given frames per second; if set, this computes and overwrites the given hop_size value. origin : int, optional Location of the window relative to the reference sample of a frame. end : int or str, optional End of signal handling (see notes below). num_frames : int, optional Number of frames to return. kwargs : dict, optional If no Signal instance was given, one is instantiated with these additional keyword arguments.

Notes

The FramedSignal class is implemented as an iterator. It splits the given signal automatically into frames of frame_size length with hop_size samples (can be float, normal rounding applies) between the frames. The reference sample of the first frame refers to the first sample of the signal.

The location of the window relative to the reference sample of a frame can be set with the origin parameter (with the same behaviour as used by scipy.ndimage filters). Arbitrary integer values can be given:

• zero centers the window on its reference sample,
• negative values shift the window to the right,
• positive values shift the window to the left.

Additionally, it can have the following literal values:

• ‘center’, ‘offline’: the window is centered on its reference sample,
• ‘left’, ‘past’, ‘online’: the window is located to the left of its reference sample (including the reference sample),
• ‘right’, ‘future’: the window is located to the right of its reference sample.

The end parameter is used to handle the end of signal behaviour and can have these values:

• ‘normal’: stop as soon as the whole signal got covered by at least one frame (i.e. pad maximally one frame),
• ‘extend’: frames are returned as long as part of the frame overlaps with the signal to cover the whole signal.

Alternatively, num_frames can be used to retrieve a fixed number of frames.

In order to be able to stack multiple frames obtained with different frame sizes, the number of frames to be returned must be independent from the set frame_size. It is not guaranteed that every sample of the signal is returned in a frame unless the origin is either ‘right’ or ‘future’.

Examples

To chop a Signal (or anything a Signal can be instantiated from) into overlapping frames of size 2048 with adjacent frames being 441 samples apart:

>>> sig = Signal('tests/data/audio/sample.wav')
>>> sig
Signal([-2494, -2510, ...,   655,   639], dtype=int16)
>>> frames = FramedSignal(sig, frame_size=2048, hop_size=441)
>>> frames  
<madmom.audio.signal.FramedSignal object at 0x...>
>>> frames[0]
Signal([    0,     0, ..., -4666, -4589], dtype=int16)
>>> frames[10]
Signal([-6156, -5645, ...,  -253,   671], dtype=int16)
>>> frames.fps
100.0

Instead of passing a Signal instance as the first argument, anything a Signal can be instantiated from (e.g. a file name) can be used. We can also set the frames per second (fps) instead, they get converted to hop_size based on the sample_rate of the signal:

>>> frames = FramedSignal('tests/data/audio/sample.wav', fps=100)
>>> frames  
<madmom.audio.signal.FramedSignal object at 0x...>
>>> frames[0]
Signal([    0,     0, ..., -4666, -4589], dtype=int16)
>>> frames.frame_size, frames.hop_size
(2048, 441.0)

When trying to access an out of range frame, an IndexError is raised. Thus the FramedSignal can be used the same way as a numpy array or any other iterable.

>>> frames = FramedSignal('tests/data/audio/sample.wav')
>>> frames.num_frames
281
>>> frames[281]
Traceback (most recent call last):
IndexError: end of signal reached
>>> frames.shape
(281, 2048)

Slices are FramedSignals itself:

>>> frames[:4]  
<madmom.audio.signal.FramedSignal object at 0x...>

To obtain a numpy array from a FramedSignal, simply use np.array() on the full FramedSignal or a slice of it. Please note, that this requires a full memory copy.

>>> np.array(frames[2:4])
array([[    0,     0, ..., -5316, -5405],
       [ 2215,  2281, ...,   561,   653]], dtype=int16)

frame_rate¶

Frame rate (same as fps).

fps¶

Frames per second.

overlap_factor¶

Overlapping factor of two adjacent frames.

shape¶

Shape of the FramedSignal (num_frames x frame_size).

ndim¶

Dimensionality of the FramedSignal.

class madmom.audio.signal.FramedSignalProcessor(frame_size=2048, hop_size=441.0, fps=None, origin=0, end='normal', num_frames=None, online=None, **kwargs)[source]¶

Slice a Signal into frames.

Parameters:

frame_size : int, optional Size of one frame [samples]. hop_size : float, optional Progress hop_size samples between adjacent frames. fps : float, optional Use given frames per second; if set, this computes and overwrites the given hop_size value. origin : int, optional Location of the window relative to the reference sample of a frame. end : int or str, optional End of signal handling (see FramedSignal). num_frames : int, optional Number of frames to return. kwargs : dict, optional If no Signal instance was given, one is instantiated with these additional keyword arguments.

Notes

The location of the window relative to its reference sample can be set with the online parameter:

• ‘False’: the window is centered on its reference sample,
• ‘True’: the window is located to the left of its reference sample (including the reference sample), i.e. only past information is used.

Examples

Processor for chopping a Signal (or anything a Signal can be instantiated from) into overlapping frames of size 2048, and a frame rate of 100 frames per second:

>>> proc = FramedSignalProcessor(frame_size=2048, fps=100)
>>> frames = proc('tests/data/audio/sample.wav')
>>> frames  
<madmom.audio.signal.FramedSignal object at 0x...>
>>> frames[0]
Signal([    0,     0, ..., -4666, -4589], dtype=int16)
>>> frames[10]
Signal([-6156, -5645, ...,  -253,   671], dtype=int16)
>>> frames.hop_size
441.0

process(data, **kwargs)[source]¶

Slice the signal into (overlapping) frames.

Parameters:	data : Signal instance Signal to be sliced into frames. kwargs : dict Keyword arguments passed to FramedSignal to instantiate the returned object.
Returns:	frames : FramedSignal instance FramedSignal instance

static add_arguments(parser, frame_size=2048, fps=None, online=None)[source]¶

Add signal framing related arguments to an existing parser.

Parameters:	parser : argparse parser instance Existing argparse parser object. frame_size : int, optional Size of one frame in samples. fps : float, optional Frames per second. online : bool, optional Online mode (use only past signal information, i.e. align the window to the left of the reference sample).
Returns:	argparse argument group Signal framing argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.

madmom.audio.filters¶

This module contains filter and filterbank related functionality.

madmom.audio.filters.hz2mel(f)[source]¶

Convert Hz frequencies to Mel.

Parameters:	f : numpy array Input frequencies [Hz].
Returns:	m : numpy array Frequencies in Mel [Mel].

madmom.audio.filters.mel2hz(m)[source]¶

Convert Mel frequencies to Hz.

Parameters:	m : numpy array Input frequencies [Mel].
Returns:	f: numpy array Frequencies in Hz [Hz].

madmom.audio.filters.mel_frequencies(num_bands, fmin, fmax)[source]¶

Returns frequencies aligned on the Mel scale.

Parameters:	num_bands : int Number of bands. fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz].
Returns:	mel_frequencies: numpy array Frequencies with Mel spacing [Hz].

madmom.audio.filters.bark_frequencies(fmin=20.0, fmax=15500.0)[source]¶

Returns frequencies aligned on the Bark scale.

Parameters:	fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz].
Returns:	bark_frequencies : numpy array Frequencies with Bark spacing [Hz].

madmom.audio.filters.bark_double_frequencies(fmin=20.0, fmax=15500.0)[source]¶

Returns frequencies aligned on the Bark-scale.

The list also includes center frequencies between the corner frequencies.

Parameters:	fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz].
Returns:	bark_frequencies : numpy array Frequencies with Bark spacing [Hz].

madmom.audio.filters.log_frequencies(bands_per_octave, fmin, fmax, fref=440.0)[source]¶

Returns frequencies aligned on a logarithmic frequency scale.

Parameters:	bands_per_octave : int Number of filter bands per octave. fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz]. fref : float, optional Tuning frequency [Hz].
Returns:	log_frequencies : numpy array Logarithmically spaced frequencies [Hz].

Notes

If bands_per_octave = 12 and fref = 440 are used, the frequencies are equivalent to MIDI notes.

madmom.audio.filters.semitone_frequencies(fmin, fmax, fref=440.0)[source]¶

Returns frequencies separated by semitones.

Parameters:	fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz]. fref : float, optional Tuning frequency of A4 [Hz].
Returns:	semitone_frequencies : numpy array Semitone frequencies [Hz].

madmom.audio.filters.hz2midi(f, fref=440.0)[source]¶

Convert frequencies to the corresponding MIDI notes.

Parameters:	f : numpy array Input frequencies [Hz]. fref : float, optional Tuning frequency of A4 [Hz].
Returns:	m : numpy array MIDI notes

Notes

For details see: at http://www.phys.unsw.edu.au/jw/notes.html This function does not necessarily return a valid MIDI Note, you may need to round it to the nearest integer.

madmom.audio.filters.midi2hz(m, fref=440.0)[source]¶

Convert MIDI notes to corresponding frequencies.

Parameters:	m : numpy array Input MIDI notes. fref : float, optional Tuning frequency of A4 [Hz].
Returns:	f : numpy array Corresponding frequencies [Hz].

madmom.audio.filters.midi_frequencies(fmin, fmax, fref=440.0)¶

Returns frequencies separated by semitones.

Parameters:	fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz]. fref : float, optional Tuning frequency of A4 [Hz].
Returns:	semitone_frequencies : numpy array Semitone frequencies [Hz].

madmom.audio.filters.hz2erb(f)[source]¶

Convert Hz to ERB.

Parameters:	f : numpy array Input frequencies [Hz].
Returns:	e : numpy array Frequencies in ERB [ERB].

Notes

Information about the ERB scale can be found at: https://ccrma.stanford.edu/~jos/bbt/Equivalent_Rectangular_Bandwidth.html

madmom.audio.filters.erb2hz(e)[source]¶

Convert ERB scaled frequencies to Hz.

Parameters:	e : numpy array Input frequencies [ERB].
Returns:	f : numpy array Frequencies in Hz [Hz].

Notes

Information about the ERB scale can be found at: https://ccrma.stanford.edu/~jos/bbt/Equivalent_Rectangular_Bandwidth.html

madmom.audio.filters.frequencies2bins(frequencies, bin_frequencies, unique_bins=False)[source]¶

Map frequencies to the closest corresponding bins.

Parameters:	frequencies : numpy array Input frequencies [Hz]. bin_frequencies : numpy array Frequencies of the (FFT) bins [Hz]. unique_bins : bool, optional Return only unique bins, i.e. remove all duplicate bins resulting from insufficient resolution at low frequencies.
Returns:	bins : numpy array Corresponding (unique) bins.

Notes

It can be important to return only unique bins, otherwise the lower frequency bins can be given too much weight if all bins are simply summed up (as in the spectral flux onset detection).

madmom.audio.filters.bins2frequencies(bins, bin_frequencies)[source]¶

Convert bins to the corresponding frequencies.

Parameters:	bins : numpy array Bins (e.g. FFT bins). bin_frequencies : numpy array Frequencies of the (FFT) bins [Hz].
Returns:	f : numpy array Corresponding frequencies [Hz].

class madmom.audio.filters.Filter(data, start=0, norm=False)[source]¶

Generic Filter class.

Parameters:	data : 1D numpy array Filter data. start : int, optional Start position (see notes). norm : bool, optional Normalize the filter area to 1.

Notes

The start position is mandatory if a Filter should be used for the creation of a Filterbank.

classmethod band_bins(bins, **kwargs)[source]¶

Must yield the center/crossover bins needed for filter creation.

Parameters:	bins : numpy array Center/crossover bins used for the creation of filters. kwargs : dict, optional Additional parameters for for the creation of filters (e.g. if the filters should overlap or not).

classmethod filters(bins, norm, **kwargs)[source]¶

Create a list with filters for the the given bins.

Parameters:	bins : list or numpy array Center/crossover bins of the filters. norm : bool Normalize the area of the filter(s) to 1. kwargs : dict, optional Additional parameters passed to band_bins() (e.g. if the filters should overlap or not).
Returns:	filters : list Filter(s) for the given bins.

class madmom.audio.filters.TriangularFilter(start, center, stop, norm=False)[source]¶

Triangular filter class.

Create a triangular shaped filter with length stop, height 1 (unless normalized) with indices <= start set to 0.

Parameters:	start : int Start bin of the filter. center : int Center bin of the filter. stop : int Stop bin of the filter. norm : bool, optional Normalize the area of the filter to 1.

classmethod band_bins(bins, overlap=True)[source]¶

Yields start, center and stop bins for creation of triangular filters.

Parameters:	bins : list or numpy array Center bins of filters. overlap : bool, optional Filters should overlap (see notes).
Yields:	start : int Start bin of the filter. center : int Center bin of the filter. stop : int Stop bin of the filter.

Notes

If overlap is ‘False’, the start and stop bins of the filters are interpolated between the centre bins, normal rounding applies.

class madmom.audio.filters.RectangularFilter(start, stop, norm=False)[source]¶

Rectangular filter class.

Create a rectangular shaped filter with length stop, height 1 (unless normalized) with indices < start set to 0.

Parameters:	start : int Start bin of the filter. stop : int Stop bin of the filter. norm : bool, optional Normalize the area of the filter to 1.

classmethod band_bins(bins, overlap=False)[source]¶

Yields start and stop bins and normalization info for creation of rectangular filters.

Parameters:	bins : list or numpy array Crossover bins of filters. overlap : bool, optional Filters should overlap.
Yields:	start : int Start bin of the filter. stop : int Stop bin of the filter.

class madmom.audio.filters.Filterbank(data, bin_frequencies)[source]¶

Generic filterbank class.

A Filterbank is a simple numpy array enhanced with several additional attributes, e.g. number of bands.

A Filterbank has a shape of (num_bins, num_bands) and can be used to filter a spectrogram of shape (num_frames, num_bins) to (num_frames, num_bands).

Parameters:	data : numpy array, shape (num_bins, num_bands) Data of the filterbank . bin_frequencies : numpy array, shape (num_bins, ) Frequencies of the bins [Hz].

Notes

The length of bin_frequencies must be equal to the first dimension of the given data array.

classmethod from_filters(filters, bin_frequencies)[source]¶

Create a filterbank with possibly multiple filters per band.

Parameters:	filters : list (of lists) of Filters List of Filters (per band); if multiple filters per band are desired, they should be also contained in a list, resulting in a list of lists of Filters. bin_frequencies : numpy array Frequencies of the bins (needed to determine the expected size of the filterbank).
Returns:	filterbank : Filterbank instance Filterbank with respective filter elements.

num_bins¶

Number of bins.

num_bands¶

Number of bands.

corner_frequencies¶

Corner frequencies of the filter bands.

center_frequencies¶

Center frequencies of the filter bands.

fmin¶

Minimum frequency of the filterbank.

fmax¶

Maximum frequency of the filterbank.

class madmom.audio.filters.FilterbankProcessor(data, bin_frequencies)[source]¶

Generic filterbank processor class.

A FilterbankProcessor is a simple wrapper for Filterbank which adds a process() method.

See also

Filterbank

process(data)[source]¶

Filter the given data with the Filterbank.

Parameters:	data : 2D numpy array Data to be filtered. Returns ——- filt_data : numpy array Filtered data.

Notes

This method makes the Filterbank act as a Processor.

static add_arguments(parser, filterbank=None, num_bands=None, crossover_frequencies=None, fmin=None, fmax=None, norm_filters=None, unique_filters=None)[source]¶

Add filterbank related arguments to an existing parser.

Parameters:

parser : argparse parser instance Existing argparse parser object. filterbank : audio.filters.Filterbank, optional Use a filterbank of that type. num_bands : int, optional Number of bands (per octave). crossover_frequencies : list or numpy array, optional List of crossover frequencies at which the spectrogram is split into bands. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filters of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

Returns:

argparse argument group Filterbank argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’. Depending on the type of the filterbank, either num_bands or crossover_frequencies should be used.

class madmom.audio.filters.MelFilterbank(bin_frequencies, num_bands=40, fmin=20.0, fmax=17000.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

Mel filterbank class.

Parameters:

bin_frequencies : numpy array Frequencies of the bins [Hz]. num_bands : int, optional Number of filter bands. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filters to area 1. unique_filters : bool, optional Keep only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

Notes

Because of rounding and mapping of frequencies to bins and back to frequencies, the actual minimum, maximum and center frequencies do not necessarily match the parameters given.

class madmom.audio.filters.BarkFilterbank(bin_frequencies, num_bands='normal', fmin=20.0, fmax=15500.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

Bark filterbank class.

Parameters:

bin_frequencies : numpy array Frequencies of the bins [Hz]. num_bands : {‘normal’, ‘double’}, optional Number of filter bands. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filters to area 1. unique_filters : bool, optional Keep only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

class madmom.audio.filters.LogarithmicFilterbank(bin_frequencies, num_bands=12, fmin=30.0, fmax=17000.0, fref=440.0, norm_filters=True, unique_filters=True, bands_per_octave=True)[source]¶

Logarithmic filterbank class.

Parameters:

bin_frequencies : numpy array Frequencies of the bins [Hz]. num_bands : int, optional Number of filter bands (per octave). fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. fref : float, optional Tuning frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filters to area 1. unique_filters : bool, optional Keep only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies. bands_per_octave : bool, optional Indicates whether num_bands is given as number of bands per octave (‘True’, default) or as an absolute number of bands (‘False’).

Notes

num_bands sets either the number of bands per octave or the total number of bands, depending on the setting of bands_per_octave. num_bands is used to set also the number of bands per octave to keep the argument for all classes the same. If 12 bands per octave are used, a filterbank with semitone spacing is created.

madmom.audio.filters.LogFilterbank¶

alias of LogarithmicFilterbank

class madmom.audio.filters.RectangularFilterbank(bin_frequencies, crossover_frequencies, fmin=30.0, fmax=17000.0, norm_filters=True, unique_filters=True)[source]¶

Rectangular filterbank class.

Parameters:

bin_frequencies : numpy array Frequencies of the bins [Hz]. crossover_frequencies : list or numpy array Crossover frequencies of the bands [Hz]. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filters to area 1. unique_filters : bool, optional Keep only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

madmom.audio.comb_filters¶

This module contains comb-filter and comb-filterbank functionality.

class madmom.audio.comb_filters.CombFilterbankProcessor¶

CombFilterbankProcessor class.

Parameters:	filter_function : filter function or str Filter function to use {feed_forward_comb_filter, feed_backward_comb_filter} or a string literal {‘forward’, ‘backward’}. tau : list or numpy array, shape (N,) Delay length(s) [frames]. alpha : list or numpy array, shape (N,) Corresponding scaling factor(s).

Notes

tau and alpha must have the same length.

Examples

Create a processor and then filter the given signal with it. The direction of the comb filter function can be given as a literal:

>>> x = np.array([0, 0, 1, 0, 0, 1, 0, 0, 1])
>>> proc = CombFilterbankProcessor('forward', [2, 3], [0.5, 0.5])
>>> proc(x)
array([[ 0. ,  0. ],
       [ 0. ,  0. ],
       [ 1. ,  1. ],
       [ 0. ,  0. ],
       [ 0.5,  0. ],
       [ 1. ,  1.5],
       [ 0. ,  0. ],
       [ 0.5,  0. ],
       [ 1. ,  1.5]])

>>> proc = CombFilterbankProcessor('backward', [2, 3], [0.5, 0.5])
>>> proc(x)
array([[ 0.   ,  0.   ],
       [ 0.   ,  0.   ],
       [ 1.   ,  1.   ],
       [ 0.   ,  0.   ],
       [ 0.5  ,  0.   ],
       [ 1.   ,  1.5  ],
       [ 0.25 ,  0.   ],
       [ 0.5  ,  0.   ],
       [ 1.125,  1.75 ]])

process(self, data)¶

Process the given data with the comb filter.

Parameters:	data : numpy array Data to be filtered/processed.
Returns:	comb_filtered_data : numpy array Comb filtered data with the different taus aligned along the (new) last dimension.

madmom.audio.comb_filters.comb_filter(signal, filter_function, tau, alpha)¶

Filter the signal with a bank of either feed forward or backward comb filters.

Parameters:	signal : numpy array Signal. filter_function : {feed_forward_comb_filter, feed_backward_comb_filter} Filter function to use (feed forward or backward). tau : list or numpy array, shape (N,) Delay length(s) [frames]. alpha : list or numpy array, shape (N,) Corresponding scaling factor(s).
Returns:	comb_filtered_signal : numpy array Comb filtered signal with the different taus aligned along the (new) last dimension.

Notes

tau and alpha must be of same length.

Examples

Filter the given signal with a bank of resonating comb filters.

>>> x = np.array([0, 0, 1, 0, 0, 1, 0, 0, 1])
>>> comb_filter(x, feed_forward_comb_filter, [2, 3], [0.5, 0.5])
array([[ 0. ,  0. ],
       [ 0. ,  0. ],
       [ 1. ,  1. ],
       [ 0. ,  0. ],
       [ 0.5,  0. ],
       [ 1. ,  1.5],
       [ 0. ,  0. ],
       [ 0.5,  0. ],
       [ 1. ,  1.5]])

Same for a backward filter:

>>> comb_filter(x, feed_backward_comb_filter, [2, 3], [0.5, 0.5])
array([[ 0.   ,  0.   ],
       [ 0.   ,  0.   ],
       [ 1.   ,  1.   ],
       [ 0.   ,  0.   ],
       [ 0.5  ,  0.   ],
       [ 1.   ,  1.5  ],
       [ 0.25 ,  0.   ],
       [ 0.5  ,  0.   ],
       [ 1.125,  1.75 ]])

madmom.audio.comb_filters.feed_backward_comb_filter(signal, tau, alpha)¶

Filter the signal with a feed backward comb filter.

Parameters:	signal : numpy array Signal. tau : int Delay length. alpha : float Scaling factor.
Returns:	comb_filtered_signal : numpy array Comb filtered signal, float dtype.

Notes

y[n] = x[n] + α * y[n - τ] is used as a filter function.

Examples

Comb filter the given signal:

>>> x = np.array([0, 0, 1, 0, 0, 1, 0, 0, 1])
>>> feed_backward_comb_filter(x, tau=3, alpha=0.5)
array([ 0.  ,  0.  ,  1.  ,  0.  ,  0.  ,  1.5 ,  0.  ,  0.  ,  1.75])

madmom.audio.comb_filters.feed_backward_comb_filter_1d(signal, tau, alpha)¶

feed_backward_comb_filter_1d is deprecated as of version 0.14 and will be removed in version 0.15. Use feed_backward_comb_filter instead.

madmom.audio.comb_filters.feed_backward_comb_filter_2d(signal, tau, alpha)¶

feed_backward_comb_filter_2d is deprecated as of version 0.14 and will be removed in version 0.15. Use feed_backward_comb_filter instead.

madmom.audio.comb_filters.feed_forward_comb_filter(signal, tau, alpha)¶

Filter the signal with a feed forward comb filter.

Parameters:	signal : numpy array Signal. tau : int Delay length. alpha : float Scaling factor.
Returns:	comb_filtered_signal : numpy array Comb filtered signal, float dtype

Notes

y[n] = x[n] + α * x[n - τ] is used as a filter function.

Examples

Comb filter the given signal:

>>> x = np.array([0, 0, 1, 0, 0, 1, 0, 0, 1])
>>> feed_forward_comb_filter(x, tau=3, alpha=0.5)
array([ 0. ,  0. ,  1. ,  0. ,  0. ,  1.5,  0. ,  0. ,  1.5])

madmom.audio.ffmpeg¶

This module contains audio handling via ffmpeg functionality.

madmom.audio.ffmpeg.decode_to_disk(infile, fmt='f32le', sample_rate=None, num_channels=1, skip=None, max_len=None, outfile=None, tmp_dir=None, tmp_suffix=None, cmd='ffmpeg')[source]¶

Decodes the given audio file, optionally down-mixes it to mono and writes it to another file as a sequence of samples. Returns the file name of the output file.

Parameters:

infile : str Name of the audio sound file to decode. fmt : {‘f32le’, ‘s16le’}, optional Format of the samples: - ‘f32le’ for float32, little-endian, - ‘s16le’ for signed 16-bit int, little-endian. sample_rate : int, optional Sample rate to re-sample the signal to (if set) [Hz]. num_channels : int, optional Number of channels to reduce the signal to. skip : float, optional Number of seconds to skip at beginning of file. max_len : float, optional Maximum length in seconds to decode. outfile : str, optional The file to decode the sound file to; if not given, a temporary file will be created. tmp_dir : str, optional The directory to create the temporary file in (if no outfile is given). tmp_suffix : str, optional The file suffix for the temporary file if no outfile is given; e.g. ”.pcm” (including the dot). cmd : {‘ffmpeg’, ‘avconv’}, optional Decoding command (defaults to ffmpeg, alternatively supports avconv).

Returns:

outfile : str The output file name.

madmom.audio.ffmpeg.decode_to_memory(infile, fmt='f32le', sample_rate=None, num_channels=1, skip=None, max_len=None, cmd='ffmpeg')[source]¶

Decodes the given audio file, down-mixes it to mono and returns it as a binary string of a sequence of samples.

Parameters:

infile : str Name of the audio sound file to decode. fmt : {‘f32le’, ‘s16le’}, optional Format of the samples: - ‘f32le’ for float32, little-endian, - ‘s16le’ for signed 16-bit int, little-endian. sample_rate : int, optional Sample rate to re-sample the signal to (if set) [Hz]. num_channels : int, optional Number of channels to reduce the signal to. skip : float, optional Number of seconds to skip at beginning of file. max_len : float, optional Maximum length in seconds to decode. cmd : {‘ffmpeg’, ‘avconv’}, optional Decoding command (defaults to ffmpeg, alternatively supports avconv).

Returns:

samples : str a binary string of samples

madmom.audio.ffmpeg.decode_to_pipe(infile, fmt='f32le', sample_rate=None, num_channels=1, skip=None, max_len=None, buf_size=-1, cmd='ffmpeg')[source]¶

Decodes the given audio file, down-mixes it to mono and returns a file-like object for reading the samples, as well as a process object. To stop decoding the file, call close() on the returned file-like object, then call wait() on the returned process object.

Parameters:

infile : str Name of the audio sound file to decode. fmt : {‘f32le’, ‘s16le’}, optional Format of the samples: - ‘f32le’ for float32, little-endian, - ‘s16le’ for signed 16-bit int, little-endian. sample_rate : int, optional Sample rate to re-sample the signal to (if set) [Hz]. num_channels : int, optional Number of channels to reduce the signal to. skip : float, optional Number of seconds to skip at beginning of file. max_len : float, optional Maximum length in seconds to decode. buf_size : int, optional Size of buffer for the file-like object: - ‘-1’ means OS default (default), - ‘0’ means unbuffered, - ‘1’ means line-buffered, any other value is the buffer size in bytes. cmd : {‘ffmpeg’,’avconv’}, optional Decoding command (defaults to ffmpeg, alternatively supports avconv).

Returns:

pipe : file-like object File-like object for reading the decoded samples. proc : process object Process object for the decoding process.

madmom.audio.ffmpeg.get_file_info(infile, cmd='ffprobe')[source]¶

Extract and return information about audio files.

Parameters:	infile : str Name of the audio file. cmd : {‘ffprobe’, ‘avprobe’}, optional Probing command (defaults to ffprobe, alternatively supports avprobe).
Returns:	dict Audio file information.

madmom.audio.ffmpeg.load_ffmpeg_file(filename, sample_rate=None, num_channels=None, start=None, stop=None, dtype=None, cmd_decode='ffmpeg', cmd_probe='ffprobe')[source]¶

Load the audio data from the given file and return it as a numpy array.

This uses ffmpeg (or avconv) and thus supports a lot of different file formats, resampling and channel conversions. The file will be fully decoded into memory if no start and stop positions are given.

Parameters:

filename : str Name of the audio sound file to load. sample_rate : int, optional Sample rate to re-sample the signal to [Hz]; ‘None’ returns the signal in its original rate. num_channels : int, optional Reduce or expand the signal to num_channels channels; ‘None’ returns the signal with its original channels. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. dtype : numpy dtype, optional Numpy dtype to return the signal in (supports signed and unsigned 8/16/32-bit integers, and single and double precision floats, each in little or big endian). If ‘None’, np.int16 is used. cmd_decode : {‘ffmpeg’, ‘avconv’}, optional Decoding command (defaults to ffmpeg, alternatively supports avconv). cmd_probe : {‘ffprobe’, ‘avprobe’}, optional Probing command (defaults to ffprobe, alternatively supports avprobe).

Returns:

signal : numpy array Audio samples. sample_rate : int Sample rate of the audio samples.

madmom.audio.stft¶

This module contains Short-Time Fourier Transform (STFT) related functionality.

madmom.audio.stft.fft_frequencies(num_fft_bins, sample_rate)[source]¶

Frequencies of the FFT bins.

Parameters:	num_fft_bins : int Number of FFT bins (i.e. half the FFT length). sample_rate : float Sample rate of the signal.
Returns:	fft_frequencies : numpy array Frequencies of the FFT bins [Hz].

madmom.audio.stft.stft(frames, window, fft_size=None, circular_shift=False)[source]¶

Calculates the complex Short-Time Fourier Transform (STFT) of the given framed signal.

Parameters:

frames : numpy array or iterable, shape (num_frames, frame_size) Framed signal (e.g. FramedSignal instance) window : numpy array, shape (frame_size,) Window (function). fft_size : int, optional FFT size (should be a power of 2); if ‘None’, the ‘frame_size’ given by frames is used; if the given fft_size is greater than the ‘frame_size’, the frames are zero-padded accordingly. circular_shift : bool, optional Circular shift the individual frames before performing the FFT; needed for correct phase.

Returns:

stft : numpy array, shape (num_frames, frame_size) The complex STFT of the framed signal.

madmom.audio.stft.phase(stft)[source]¶

Returns the phase of the complex STFT of a signal.

Parameters:	stft : numpy array, shape (num_frames, frame_size) The complex STFT of a signal.
Returns:	phase : numpy array Phase of the STFT.

madmom.audio.stft.local_group_delay(phase)[source]¶

Returns the local group delay of the phase of a signal.

Parameters:	phase : numpy array, shape (num_frames, frame_size) Phase of the STFT of a signal.
Returns:	lgd : numpy array Local group delay of the phase.

madmom.audio.stft.lgd(phase)¶

Returns the local group delay of the phase of a signal.

Parameters:	phase : numpy array, shape (num_frames, frame_size) Phase of the STFT of a signal.
Returns:	lgd : numpy array Local group delay of the phase.

class madmom.audio.stft.ShortTimeFourierTransform(frames, window=<function hanning>, fft_size=None, circular_shift=False, **kwargs)[source]¶

ShortTimeFourierTransform class.

Parameters:

frames : audio.signal.FramedSignal instance Framed signal. window : numpy ufunc or numpy array, optional Window (function); if a function (e.g. np.hanning) is given, a window with the frame size of frames and the given shape is created. fft_size : int, optional FFT size (should be a power of 2); if ‘None’, the frame_size given by frames is used, if the given fft_size is greater than the frame_size, the frames are zero-padded accordingly. circular_shift : bool, optional Circular shift the individual frames before performing the FFT; needed for correct phase. kwargs : dict, optional If no audio.signal.FramedSignal instance was given, one is instantiated with these additional keyword arguments.

Notes

If the Signal (wrapped in the FramedSignal) has an integer dtype, the window is automatically scaled as if the signal had a float dtype with the values being in the range [-1, 1]. This results in same valued STFTs independently of the dtype of the signal. On the other hand, this prevents extra memory consumption since the data-type of the signal does not need to be converted (and if no decoding is needed, the audio signal can be memory-mapped).

Examples

Create a ShortTimeFourierTransform from a Signal or FramedSignal:

>>> sig = Signal('tests/data/audio/sample.wav')
>>> sig
Signal([-2494, -2510, ...,   655,   639], dtype=int16)
>>> frames = FramedSignal(sig, frame_size=2048, hop_size=441)
>>> frames  
<madmom.audio.signal.FramedSignal object at 0x...>
>>> stft = ShortTimeFourierTransform(frames)
>>> stft  
ShortTimeFourierTransform([[-3.15249+0.j     ,  2.62216-3.02425j, ...,
                            -0.03634-0.00005j,  0.03670+0.00029j],
                           [-4.28429+0.j     ,  2.02009+2.01264j, ...,
                            -0.01981-0.00933j, -0.00536+0.02162j],
                           ...,
                           [-4.92274+0.j     ,  4.09839-9.42525j, ...,
                             0.00550-0.00257j,  0.00137+0.00577j],
                           [-9.22709+0.j     ,  8.76929+4.0005j , ...,
                             0.00981-0.00014j, -0.00984+0.00006j]],
                          dtype=complex64)

A ShortTimeFourierTransform can be instantiated directly from a file name:

>>> stft = ShortTimeFourierTransform('tests/data/audio/sample.wav')
>>> stft  
ShortTimeFourierTransform([[...]], dtype=complex64)

Doing the same with a Signal of float data-type will result in a STFT of same value range (rounding errors will occur of course):

>>> sig = Signal('tests/data/audio/sample.wav', dtype=np.float)
>>> sig  
Signal([-0.07611, -0.0766 , ...,  0.01999,  0.0195 ])
>>> frames = FramedSignal(sig, frame_size=2048, hop_size=441)
>>> frames  
<madmom.audio.signal.FramedSignal object at 0x...>
>>> stft = ShortTimeFourierTransform(frames)
>>> stft  
ShortTimeFourierTransform([[-3.15240+0.j     ,  2.62208-3.02415j, ...,
                            -0.03633-0.00005j,  0.03670+0.00029j],
                           [-4.28416+0.j     ,  2.02003+2.01257j, ...,
                            -0.01981-0.00933j, -0.00536+0.02162j],
                           ...,
                           [-4.92259+0.j     ,  4.09827-9.42496j, ...,
                             0.00550-0.00257j,  0.00137+0.00577j],
                           [-9.22681+0.j     ,  8.76902+4.00038j, ...,
                             0.00981-0.00014j, -0.00984+0.00006j]],
                          dtype=complex64)

Additional arguments are passed to FramedSignal and Signal respectively:

>>> stft = ShortTimeFourierTransform('tests/data/audio/sample.wav', frame_size=2048, fps=100, sample_rate=22050)
>>> stft.frames  
<madmom.audio.signal.FramedSignal object at 0x...>
>>> stft.frames.frame_size
2048
>>> stft.frames.hop_size
220.5
>>> stft.frames.signal.sample_rate
22050

spec(**kwargs)[source]¶

Returns the magnitude spectrogram of the STFT.

Parameters:	kwargs : dict, optional Keyword arguments passed to audio.spectrogram.Spectrogram.
Returns:	spec : audio.spectrogram.Spectrogram audio.spectrogram.Spectrogram instance.

phase(**kwargs)[source]¶

Returns the phase of the STFT.

Parameters:	kwargs : dict, optional keyword arguments passed to Phase.
Returns:	phase : Phase Phase instance.

madmom.audio.stft.STFT¶

alias of ShortTimeFourierTransform

class madmom.audio.stft.ShortTimeFourierTransformProcessor(window=<function hanning>, fft_size=None, circular_shift=False, **kwargs)[source]¶

ShortTimeFourierTransformProcessor class.

Parameters:	window : numpy ufunc, optional Window function. fft_size : int, optional FFT size (should be a power of 2); if ‘None’, it is determined by the size of the frames; if is greater than the frame size, the frames are zero-padded accordingly. circular_shift : bool, optional Circular shift the individual frames before performing the FFT; needed for correct phase.

Examples

Create a ShortTimeFourierTransformProcessor and call it with either a file name or a the output of a (Framed-)SignalProcessor to obtain a ShortTimeFourierTransform instance.

>>> proc = ShortTimeFourierTransformProcessor()
>>> stft = proc('tests/data/audio/sample.wav')
>>> stft  
ShortTimeFourierTransform([[-3.15249+0.j     ,  2.62216-3.02425j, ...,
                            -0.03634-0.00005j,  0.03670+0.00029j],
                           [-4.28429+0.j     ,  2.02009+2.01264j, ...,
                            -0.01981-0.00933j, -0.00536+0.02162j],
                           ...,
                           [-4.92274+0.j     ,  4.09839-9.42525j, ...,
                             0.00550-0.00257j,  0.00137+0.00577j],
                           [-9.22709+0.j     ,  8.76929+4.0005j , ...,
                             0.00981-0.00014j, -0.00984+0.00006j]],
                          dtype=complex64)

process(data, **kwargs)[source]¶

Perform FFT on a framed signal and return the STFT.

Parameters:	data : numpy array Data to be processed. kwargs : dict, optional Keyword arguments passed to ShortTimeFourierTransform.
Returns:	stft : ShortTimeFourierTransform ShortTimeFourierTransform instance.

static add_arguments(parser, window=None, fft_size=None)[source]¶

Add STFT related arguments to an existing parser.

Parameters:	parser : argparse parser instance Existing argparse parser. window : numpy ufunc, optional Window function. fft_size : int, optional Use this size for FFT (should be a power of 2).
Returns:	argparse argument group STFT argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.

madmom.audio.stft.STFTProcessor¶

alias of ShortTimeFourierTransformProcessor

class madmom.audio.stft.Phase(stft, **kwargs)[source]¶

Phase class.

Parameters:	stft : ShortTimeFourierTransform instance ShortTimeFourierTransform instance. kwargs : dict, optional If no ShortTimeFourierTransform instance was given, one is instantiated with these additional keyword arguments.

Examples

Create a Phase from a ShortTimeFourierTransform (or anything it can be instantiated from:

>>> stft = ShortTimeFourierTransform('tests/data/audio/sample.wav')
>>> phase = Phase(stft)
>>> phase  
Phase([[ 3.14159, -0.85649, ..., -3.14016,  0.00779],
       [ 3.14159,  0.78355, ..., -2.70136,  1.81393],
       ...,
       [ 3.14159, -1.16063, ..., -0.4373 ,  1.33774],
       [ 3.14159,  0.42799, ..., -0.0142 ,  3.13592]], dtype=float32)

local_group_delay(**kwargs)[source]¶

Returns the local group delay of the phase.

Parameters:	kwargs : dict, optional Keyword arguments passed to LocalGroupDelay.
Returns:	lgd : LocalGroupDelay instance LocalGroupDelay instance.

lgd(**kwargs)¶

Returns the local group delay of the phase.

Parameters:	kwargs : dict, optional Keyword arguments passed to LocalGroupDelay.
Returns:	lgd : LocalGroupDelay instance LocalGroupDelay instance.

class madmom.audio.stft.LocalGroupDelay(phase, **kwargs)[source]¶

Local Group Delay class.

Parameters:	stft : Phase instance Phase instance. kwargs : dict, optional If no Phase instance was given, one is instantiated with these additional keyword arguments.

Examples

Create a LocalGroupDelay from a ShortTimeFourierTransform (or anything it can be instantiated from:

>>> stft = ShortTimeFourierTransform('tests/data/audio/sample.wav')
>>> lgd = LocalGroupDelay(stft)
>>> lgd  
LocalGroupDelay([[-2.2851 , -2.25605, ...,  3.13525,  0. ],
                 [ 2.35804,  2.53786, ...,  1.76788,  0. ],
                 ...,
                 [-1.98..., -2.93039, ..., -1.77505,  0. ],
                 [ 2.7136 ,  2.60925, ...,  3.13318,  0. ]])

madmom.audio.stft.LGD¶

alias of LocalGroupDelay

madmom.audio.spectrogram¶

This module contains spectrogram related functionality.

madmom.audio.spectrogram.spec(stft)[source]¶

Computes the magnitudes of the complex Short Time Fourier Transform of a signal.

Parameters:	stft : numpy array Complex STFT of a signal.
Returns:	spec : numpy array Magnitude spectrogram.

class madmom.audio.spectrogram.Spectrogram(stft, **kwargs)[source]¶

A Spectrogram represents the magnitude spectrogram of a audio.stft.ShortTimeFourierTransform.

Parameters:	stft : audio.stft.ShortTimeFourierTransform instance Short Time Fourier Transform. kwargs : dict, optional If no audio.stft.ShortTimeFourierTransform instance was given, one is instantiated with these additional keyword arguments.

Examples

Create a Spectrogram from a audio.stft.ShortTimeFourierTransform (or anything it can be instantiated from:

>>> spec = Spectrogram('tests/data/audio/sample.wav')
>>> spec  
Spectrogram([[ 3.15249,  4.00272, ...,  0.03634,  0.03671],
             [ 4.28429,  2.85158, ...,  0.0219 ,  0.02227],
             ...,
             [ 4.92274, 10.27775, ...,  0.00607,  0.00593],
             [ 9.22709,  9.6387 , ...,  0.00981,  0.00984]], dtype=float32)

num_frames¶

Number of frames.

num_bins¶

Number of bins.

diff(**kwargs)[source]¶

Return the difference of the magnitude spectrogram.

Parameters:	kwargs : dict Keyword arguments passed to SpectrogramDifference.
Returns:	diff : SpectrogramDifference instance The differences of the magnitude spectrogram.

filter(**kwargs)[source]¶

Return a filtered version of the magnitude spectrogram.

Parameters:	kwargs : dict Keyword arguments passed to FilteredSpectrogram.
Returns:	filt_spec : FilteredSpectrogram instance Filtered version of the magnitude spectrogram.

log(**kwargs)[source]¶

Return a logarithmically scaled version of the magnitude spectrogram.

Parameters:	kwargs : dict Keyword arguments passed to LogarithmicSpectrogram.
Returns:	log_spec : LogarithmicSpectrogram instance Logarithmically scaled version of the magnitude spectrogram.

class madmom.audio.spectrogram.SpectrogramProcessor(**kwargs)[source]¶

SpectrogramProcessor class.

process(data, **kwargs)[source]¶

Create a Spectrogram from the given data.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to Spectrogram.
Returns:	spec : Spectrogram instance Spectrogram.

class madmom.audio.spectrogram.FilteredSpectrogram(spectrogram, filterbank=<class 'madmom.audio.filters.LogarithmicFilterbank'>, num_bands=12, fmin=30.0, fmax=17000.0, fref=440.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

FilteredSpectrogram class.

Parameters:

spectrogram : Spectrogram instance Spectrogram. filterbank : audio.filters.Filterbank, optional Filterbank class or instance; if a class is given (rather than an instance), one will be created with the given type and parameters. num_bands : int, optional Number of filter bands (per octave, depending on the type of the filterbank). fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. fref : float, optional Tuning frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filter bands of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies. kwargs : dict, optional If no Spectrogram instance was given, one is instantiated with these additional keyword arguments.

Examples

Create a FilteredSpectrogram from a Spectrogram (or anything it can be instantiated from. Per default a madmom.audio.filters.LogarithmicFilterbank with 12 bands per octave is used.

>>> spec = FilteredSpectrogram('tests/data/audio/sample.wav')
>>> spec  
FilteredSpectrogram([[  5.66156, 6.30141, ..., 0.05426, 0.06461],
                     [  8.44266, 8.69582, ..., 0.07703, 0.0902 ],
                     ...,
                     [ 10.04626, 1.12018, ..., 0.0487 , 0.04282],
                     [  8.60186, 6.81195, ..., 0.03721, 0.03371]],
                    dtype=float32)

The resulting spectrogram has fewer frequency bins, with the centers of the bins aligned logarithmically (lower frequency bins still have a linear spacing due to the coarse resolution of the DFT at low frequencies):

>>> spec.shape
(281, 81)
>>> spec.num_bins
81
>>> spec.bin_frequencies  
array([    43.06641,    64.59961,    86.13281,   107.66602,
          129.19922,   150.73242,   172.26562,   193.79883, ...,
        10551.26953, 11175.73242, 11843.26172, 12553.85742,
        13285.98633, 14082.71484, 14922.50977, 15805.37109])

The filterbank used to filter the spectrogram is saved as an attribute:

>>> spec.filterbank  
LogarithmicFilterbank([[ 0., 0., ..., 0., 0.],
                       [ 0., 0., ..., 0., 0.],
                       ...,
                       [ 0., 0., ..., 0., 0.],
                       [ 0., 0., ..., 0., 0.]], dtype=float32)
>>> spec.filterbank.num_bands
81

The filterbank can be chosen at instantiation time:

>>> from madmom.audio.filters import MelFilterbank
>>> spec = FilteredSpectrogram('tests/data/audio/sample.wav',     filterbank=MelFilterbank, num_bands=40)
>>> type(spec.filterbank)
<class 'madmom.audio.filters.MelFilterbank'>
>>> spec.shape
(281, 40)

class madmom.audio.spectrogram.FilteredSpectrogramProcessor(filterbank=<class 'madmom.audio.filters.LogarithmicFilterbank'>, num_bands=12, fmin=30.0, fmax=17000.0, fref=440.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

FilteredSpectrogramProcessor class.

Parameters:

filterbank : audio.filters.Filterbank Filterbank used to filter a spectrogram. num_bands : int Number of bands (per octave). fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. fref : float, optional Tuning frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filter of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

process(data, **kwargs)[source]¶

Create a FilteredSpectrogram from the given data.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to FilteredSpectrogram.
Returns:	filt_spec : FilteredSpectrogram instance Filtered spectrogram.

class madmom.audio.spectrogram.LogarithmicSpectrogram(spectrogram, log=<ufunc 'log10'>, mul=1.0, add=1.0, **kwargs)[source]¶

LogarithmicSpectrogram class.

Parameters:

spectrogram : Spectrogram instance Spectrogram. log : numpy ufunc, optional Logarithmic scaling function to apply. mul : float, optional Multiply the magnitude spectrogram with this factor before taking the logarithm. add : float, optional Add this value before taking the logarithm of the magnitudes. kwargs : dict, optional If no Spectrogram instance was given, one is instantiated with these additional keyword arguments.

Examples

Create a LogarithmicSpectrogram from a Spectrogram (or anything it can be instantiated from. Per default np.log10 is used as the scaling function and a value of 1 is added to avoid negative values.

>>> spec = LogarithmicSpectrogram('tests/data/audio/sample.wav')
>>> spec  
LogarithmicSpectrogram([[...]], dtype=float32)
>>> spec.min()
LogarithmicSpectrogram(1.604927092557773e-06, dtype=float32)

class madmom.audio.spectrogram.LogarithmicSpectrogramProcessor(log=<ufunc 'log10'>, mul=1.0, add=1.0, **kwargs)[source]¶

Logarithmic Spectrogram Processor class.

Parameters:	log : numpy ufunc, optional Loagrithmic scaling function to apply. mul : float, optional Multiply the magnitude spectrogram with this factor before taking the logarithm. add : float, optional Add this value before taking the logarithm of the magnitudes.

process(data, **kwargs)[source]¶

Perform logarithmic scaling of a spectrogram.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to LogarithmicSpectrogram.
Returns:	log_spec : LogarithmicSpectrogram instance Logarithmically scaled spectrogram.

static add_arguments(parser, log=None, mul=None, add=None)[source]¶

Add spectrogram scaling related arguments to an existing parser.

Parameters:	parser : argparse parser instance Existing argparse parser object. log : bool, optional Take the logarithm of the spectrogram. mul : float, optional Multiply the magnitude spectrogram with this factor before taking the logarithm. add : float, optional Add this value before taking the logarithm of the magnitudes.
Returns:	argparse argument group Spectrogram scaling argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.

class madmom.audio.spectrogram.LogarithmicFilteredSpectrogram(spectrogram, **kwargs)[source]¶

LogarithmicFilteredSpectrogram class.

Parameters:	spectrogram : FilteredSpectrogram instance Filtered spectrogram. kwargs : dict, optional If no FilteredSpectrogram instance was given, one is instantiated with these additional keyword arguments and logarithmically scaled afterwards, i.e. passed to LogarithmicSpectrogram.

See also

FilteredSpectrogram, LogarithmicSpectrogram

Notes

For the filtering and scaling parameters, please refer to FilteredSpectrogram and LogarithmicSpectrogram.

Examples

Create a LogarithmicFilteredSpectrogram from a Spectrogram (or anything it can be instantiated from. This is mainly a convenience class which first filters the spectrogram and then scales it logarithmically.

>>> spec = LogarithmicFilteredSpectrogram('tests/data/audio/sample.wav')
>>> spec  
LogarithmicFilteredSpectrogram([[ 0.82358, 0.86341, ...,
                                  0.02295, 0.02719],
                                [ 0.97509, 0.98658, ...,
                                  0.03223, 0.0375 ],
                                ...,
                                [ 1.04322, 0.32637, ...,
                                  0.02065, 0.01821],
                                [ 0.98236, 0.89276, ...,
                                  0.01587, 0.0144 ]], dtype=float32)
>>> spec.shape
(281, 81)
>>> spec.filterbank  
LogarithmicFilterbank([[...]], dtype=float32)
>>> spec.min()  
LogarithmicFilteredSpectrogram(0.00830..., dtype=float32)

class madmom.audio.spectrogram.LogarithmicFilteredSpectrogramProcessor(filterbank=<class 'madmom.audio.filters.LogarithmicFilterbank'>, num_bands=12, fmin=30.0, fmax=17000.0, fref=440.0, norm_filters=True, unique_filters=True, mul=1.0, add=1.0, **kwargs)[source]¶

Logarithmic Filtered Spectrogram Processor class.

Parameters:

filterbank : audio.filters.Filterbank Filterbank used to filter a spectrogram. num_bands : int Number of bands (per octave). fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. fref : float, optional Tuning frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filter of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies. mul : float, optional Multiply the magnitude spectrogram with this factor before taking the logarithm. add : float, optional Add this value before taking the logarithm of the magnitudes.

process(data, **kwargs)[source]¶

Perform filtering and logarithmic scaling of a spectrogram.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to LogarithmicFilteredSpectrogram.
Returns:	log_filt_spec : LogarithmicFilteredSpectrogram instance Logarithmically scaled filtered spectrogram.

class madmom.audio.spectrogram.SpectrogramDifference(spectrogram, diff_ratio=0.5, diff_frames=None, diff_max_bins=None, positive_diffs=False, **kwargs)[source]¶

SpectrogramDifference class.

Parameters:

spectrogram : Spectrogram instance Spectrogram. diff_ratio : float, optional Calculate the difference to the frame at which the window used for the STFT yields this ratio of the maximum height. diff_frames : int, optional Calculate the difference to the diff_frames-th previous frame (if set, this overrides the value calculated from the diff_ratio) diff_max_bins : int, optional Apply a maximum filter with this width (in bins in frequency dimension) to the spectrogram the difference is calculated to. positive_diffs : bool, optional Keep only the positive differences, i.e. set all diff values < 0 to 0. kwargs : dict, optional If no Spectrogram instance was given, one is instantiated with these additional keyword arguments.

Notes

The SuperFlux algorithm [R2] uses a maximum filtered spectrogram with 3 diff_max_bins together with a 24 band logarithmic filterbank to calculate the difference spectrogram with a diff_ratio of 0.5.

The effect of this maximum filter applied to the spectrogram is that the magnitudes are “widened” in frequency direction, i.e. the following difference calculation is less sensitive against frequency fluctuations. This effect is exploited to suppress false positive energy fragments originating from vibrato.

References

[R2]	(1, 2) Sebastian Böck and Gerhard Widmer “Maximum Filter Vibrato Suppression for Onset Detection” Proceedings of the 16th International Conference on Digital Audio Effects (DAFx), 2013.

Examples

To obtain the SuperFlux feature as described above first create a filtered and logarithmically spaced spectrogram:

>>> spec = LogarithmicFilteredSpectrogram('tests/data/audio/sample.wav',                                               num_bands=24, fps=200)
>>> spec  
LogarithmicFilteredSpectrogram([[ 0.82358, 0.86341, ...,
                                  0.02809, 0.02672],
                                [ 0.92514, 0.93211, ...,
                                  0.03607, 0.0317 ],
                                ...,
                                [ 1.03826, 0.767  , ...,
                                  0.01814, 0.01138],
                                [ 0.98236, 0.89276, ...,
                                  0.01669, 0.00919]], dtype=float32)
>>> spec.shape
(561, 140)

Then use the temporal first order difference and apply a maximum filter with 3 bands, keeping only the positive differences (i.e. rise in energy):

>>> superflux = SpectrogramDifference(spec, diff_max_bins=3,                                           positive_diffs=True)
>>> superflux  
SpectrogramDifference([[ 0.     , 0. , ...,  0. ,  0. ],
                       [ 0.     , 0. , ...,  0. ,  0. ],
                       ...,
                       [ 0.01941, 0. , ...,  0. ,  0. ],
                       [ 0.     , 0. , ...,  0. ,  0. ]], dtype=float32)

positive_diff()[source]¶

Positive diff.

class madmom.audio.spectrogram.SpectrogramDifferenceProcessor(diff_ratio=0.5, diff_frames=None, diff_max_bins=None, positive_diffs=False, stack_diffs=None, **kwargs)[source]¶

Difference Spectrogram Processor class.

Parameters:

diff_ratio : float, optional Calculate the difference to the frame at which the window used for the STFT yields this ratio of the maximum height. diff_frames : int, optional Calculate the difference to the diff_frames-th previous frame (if set, this overrides the value calculated from the diff_ratio) diff_max_bins : int, optional Apply a maximum filter with this width (in bins in frequency dimension) to the spectrogram the difference is calculated to. positive_diffs : bool, optional Keep only the positive differences, i.e. set all diff values < 0 to 0. stack_diffs : numpy stacking function, optional If ‘None’, only the differences are returned. If set, the diffs are stacked with the underlying spectrogram data according to the stack function: np.vstack the differences and spectrogram are stacked vertically, i.e. in time direction, np.hstack the differences and spectrogram are stacked horizontally, i.e. in frequency direction, np.dstack the differences and spectrogram are stacked in depth, i.e. return them as a 3D representation with depth as the third dimension.

process(data, **kwargs)[source]¶

Perform a temporal difference calculation on the given data.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to SpectrogramDifference.
Returns:	diff : SpectrogramDifference instance Spectrogram difference.

static add_arguments(parser, diff=None, diff_ratio=None, diff_frames=None, diff_max_bins=None, positive_diffs=None)[source]¶

Add spectrogram difference related arguments to an existing parser.

Parameters:

parser : argparse parser instance Existing argparse parser object. diff : bool, optional Take the difference of the spectrogram. diff_ratio : float, optional Calculate the difference to the frame at which the window used for the STFT yields this ratio of the maximum height. diff_frames : int, optional Calculate the difference to the diff_frames-th previous frame (if set, this overrides the value calculated from the diff_ratio) diff_max_bins : int, optional Apply a maximum filter with this width (in bins in frequency dimension) to the spectrogram the difference is calculated to. positive_diffs : bool, optional Keep only the positive differences, i.e. set all diff values < 0 to 0.

Returns:

argparse argument group Spectrogram difference argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.

Only the diff_frames parameter behaves differently, it is included if either the diff_ratio is set or a value != ‘None’ is given.

class madmom.audio.spectrogram.SuperFluxProcessor(**kwargs)[source]¶

Spectrogram processor which sets the default values suitable for the SuperFlux algorithm.

class madmom.audio.spectrogram.MultiBandSpectrogram(spectrogram, crossover_frequencies, fmin=30.0, fmax=17000.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

MultiBandSpectrogram class.

Parameters:

spectrogram : Spectrogram instance Spectrogram. crossover_frequencies : list or numpy array List of crossover frequencies at which the spectrogram is split into multiple bands. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filter bands of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies. kwargs : dict, optional If no Spectrogram instance was given, one is instantiated with these additional keyword arguments.

Notes

The MultiBandSpectrogram is implemented as a Spectrogram which uses a audio.filters.RectangularFilterbank to combine multiple frequency bins.

class madmom.audio.spectrogram.MultiBandSpectrogramProcessor(crossover_frequencies, fmin=30.0, fmax=17000.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

Spectrogram processor which combines the spectrogram magnitudes into multiple bands.

Parameters:

crossover_frequencies : list or numpy array List of crossover frequencies at which a spectrogram is split into the individual bands. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filter bands of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

process(data, **kwargs)[source]¶

Return the a multi-band representation of the given data.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to MultiBandSpectrogram.
Returns:	multi_band_spec : MultiBandSpectrogram instance Spectrogram split into multiple bands.

madmom.audio.chroma¶

This module contains chroma related functionality.

class madmom.audio.chroma.DeepChromaProcessor(fmin=65, fmax=2100, unique_filters=True, models=None, **kwargs)[source]¶

Compute chroma vectors from an audio file using a deep neural network that focuses on harmonically relevant spectral content.

Parameters:	fmin : int, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies. models : list of filenames, optional List of model filenames.

Notes

Provided model files must be compatible with the processing pipeline and the values of fmin, fmax, and unique_filters. The general use case for the models parameter is to use a specific model instead of an ensemble of all models.

The models shipped with madmom differ slightly from those presented in the paper (less hidden units, narrower frequency band for spectrogram), but achieve similar results.

References

[R1]	Filip Korzeniowski and Gerhard Widmer, “Feature Learning for Chord Recognition: The Deep Chroma Extractor”, Proceedings of the 17th International Society for Music Information Retrieval Conference (ISMIR), 2016.

Examples

Extract a chroma vector using the deep chroma extractor:

>>> dcp = DeepChromaProcessor()
>>> chroma = dcp('tests/data/audio/sample2.wav')
>>> chroma  
array([[ 0.01317,  0.00721,  ...,  0.00546,  0.00943],
       [ 0.36809,  0.01314,  ...,  0.02213,  0.01838],
       ...,
       [ 0.1534 ,  0.06475,  ...,  0.00896,  0.05789],
       [ 0.17513,  0.0729 ,  ...,  0.00945,  0.06913]], dtype=float32)
>>> chroma.shape
(41, 12)

madmom.features.beats¶

This module contains beat tracking related functionality.

class madmom.features.beats.RNNBeatProcessor(post_processor=<function average_predictions>, **kwargs)[source]¶

Processor to get a beat activation function from multiple RNNs.

Parameters:	post_processor : Processor, optional Post-processor, default is to average the predictions.

References

[R14]

Sebastian Böck and Markus Schedl, “Enhanced Beat Tracking with Context-Aware Neural Networks”, Proceedings of the 14th International Conference on Digital Audio Effects (DAFx), 2011.

Examples

Create a RNNBeatProcessor and pass a file through the processor. The returned 1d array represents the probability of a beat at each frame, sampled at 100 frames per second.

>>> proc = RNNBeatProcessor()
>>> proc  
<madmom.features.beats.RNNBeatProcessor object at 0x...>
>>> proc('tests/data/audio/sample.wav')  
array([ 0.00479,  0.00603,  0.00927,  0.01419,  0.02342, ...,
        0.00411,  0.00517,  0.00757,  0.01289,  0.02725], dtype=float32)

class madmom.features.beats.RNNDownBeatProcessor(**kwargs)[source]¶

Processor to get a joint beat and downbeat activation function from multiple RNNs.

References

[R15]

Sebastian Böck, Florian Krebs and Gerhard Widmer, “Joint Beat and Downbeat Tracking with Recurrent Neural Networks” Proceedings of the 17th International Society for Music Information Retrieval Conference (ISMIR), 2016.

Examples

Create a RNNDownBeatProcessor and pass a file through the processor. The returned 2d array represents the probabilities at each frame, sampled at 100 frames per second. The columns represent ‘beat’ and ‘downbeat’.

>>> proc = RNNDownBeatProcessor()
>>> proc  
<madmom.features.beats.RNNDownBeatProcessor object at 0x...>
>>> proc('tests/data/audio/sample.wav')
... 
array([[ 0.00011,  0.00037],
       [ 0.00008,  0.00043],
       ...,
       [ 0.00791,  0.00169],
       [ 0.03425,  0.00494]], dtype=float32)

class madmom.features.beats.MultiModelSelectionProcessor(num_ref_predictions, **kwargs)[source]¶

Processor for selecting the most suitable model (i.e. the predictions thereof) from a multiple models/predictions.

Parameters:	num_ref_predictions : int Number of reference predictions (see below).

Notes

This processor selects the most suitable prediction from multiple models by comparing them to the predictions of a reference model. The one with the smallest mean squared error is chosen.

If num_ref_predictions is 0 or None, an averaged prediction is computed from the given predictions and used as reference.

References

[R16]

Sebastian Böck, Florian Krebs and Gerhard Widmer, “A Multi-Model Approach to Beat Tracking Considering Heterogeneous Music Styles”, Proceedings of the 15th International Society for Music Information Retrieval Conference (ISMIR), 2014.

Examples

The MultiModelSelectionProcessor takes a list of model predictions as it’s call argument. Thus, ppost_processor of RNNBeatProcessor hast to be set to ‘None’ in order to get the predictions of all models.

>>> proc = RNNBeatProcessor(post_processor=None)
>>> proc  
<madmom.features.beats.RNNBeatProcessor object at 0x...>

When passing a file through the processor, a list with predictions, one for each model tested, is returned.

>>> predictions = proc('tests/data/audio/sample.wav')
>>> predictions  
[array([ 0.00535,  0.00774,  ...,  0.02343,  0.04931], dtype=float32),
 array([ 0.0022 ,  0.00282,  ...,  0.00825,  0.0152 ], dtype=float32),
 ...,
 array([ 0.005  ,  0.0052 ,  ...,  0.00472,  0.01524], dtype=float32),
 array([ 0.00319,  0.0044 ,  ...,  0.0081 ,  0.01498], dtype=float32)]

We can feed these predictions to the MultiModelSelectionProcessor. Since we do not have a dedicated reference prediction (which had to be the first element of the list and num_ref_predictions set to 1), we simply set num_ref_predictions to ‘None’. MultiModelSelectionProcessor averages all predictions to obtain a reference prediction it compares all others to.

>>> mm_proc = MultiModelSelectionProcessor(num_ref_predictions=None)
>>> mm_proc(predictions)  
array([ 0.00759,  0.00901,  ...,  0.00843,  0.01834], dtype=float32)

process(predictions)[source]¶

Selects the most appropriate predictions form the list of predictions.

Parameters:	predictions : list Predictions (beat activation functions) of multiple models.
Returns:	numpy array Most suitable prediction.

Notes

The reference beat activation function must be the first one in the list of given predictions.

madmom.features.beats.detect_beats(activations, interval, look_aside=0.2)[source]¶

Detects the beats in the given activation function as in [R17].

Parameters:	activations : numpy array Beat activations. interval : int Look for the next beat each interval frames. look_aside : float Look this fraction of the interval to each side to detect the beats.
Returns:	numpy array Beat positions [frames].

Notes

A Hamming window of 2 * look_aside * interval is applied around the position where the beat is expected to prefer beats closer to the centre.

References

[R17]

(1, 2) Sebastian Böck and Markus Schedl, “Enhanced Beat Tracking with Context-Aware Neural Networks”, Proceedings of the 14th International Conference on Digital Audio Effects (DAFx), 2011.

class madmom.features.beats.BeatTrackingProcessor(look_aside=0.2, look_ahead=10, fps=None, **kwargs)[source]¶

Track the beats according to previously determined (local) tempo by iteratively aligning them around the estimated position [R18].

Parameters:	look_aside : float, optional Look this fraction of the estimated beat interval to each side of the assumed next beat position to look for the most likely position of the next beat. look_ahead : float, optional Look look_ahead seconds in both directions to determine the local tempo and align the beats accordingly. fps : float, optional Frames per second.

Notes

If look_ahead is not set, a constant tempo throughout the whole piece is assumed. If look_ahead is set, the local tempo (in a range +/- look_ahead seconds around the actual position) is estimated and then the next beat is tracked accordingly. This procedure is repeated from the new position to the end of the piece.

Instead of the auto-correlation based method for tempo estimation proposed in [R18], it uses a comb filter based method [R19] per default. The behaviour can be controlled with the tempo_method parameter.

References

[R18]

(1, 2, 3) Sebastian Böck and Markus Schedl, “Enhanced Beat Tracking with Context-Aware Neural Networks”, Proceedings of the 14th International Conference on Digital Audio Effects (DAFx), 2011.

[R19]

(1, 2) Sebastian Böck, Florian Krebs and Gerhard Widmer, “Accurate Tempo Estimation based on Recurrent Neural Networks and Resonating Comb Filters”, Proceedings of the 16th International Society for Music Information Retrieval Conference (ISMIR), 2015.

Examples

Create a BeatTrackingProcessor. The returned array represents the positions of the beats in seconds, thus the expected sampling rate has to be given.

>>> proc = BeatTrackingProcessor(fps=100)
>>> proc  
<madmom.features.beats.BeatTrackingProcessor object at 0x...>

Call this BeatTrackingProcessor with the beat activation function returned by RNNBeatProcessor to obtain the beat positions.

>>> act = RNNBeatProcessor()('tests/data/audio/sample.wav')
>>> proc(act)
array([ 0.11,  0.45,  0.79,  1.13,  1.47,  1.81,  2.15,  2.49])

process(activations)[source]¶

Detect the beats in the given activation function.

Parameters:	activations : numpy array Beat activation function.
Returns:	beats : numpy array Detected beat positions [seconds].

static add_arguments(parser, look_aside=0.2, look_ahead=10)[source]¶

Add beat tracking related arguments to an existing parser.

Parameters:	parser : argparse parser instance Existing argparse parser object. look_aside : float, optional Look this fraction of the estimated beat interval to each side of the assumed next beat position to look for the most likely position of the next beat. look_ahead : float, optional Look look_ahead seconds in both directions to determine the local tempo and align the beats accordingly.
Returns:	parser_group : argparse argument group Beat tracking argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.

class madmom.features.beats.BeatDetectionProcessor(look_aside=0.2, fps=None, **kwargs)[source]¶

Class for detecting beats according to the previously determined global tempo by iteratively aligning them around the estimated position [R21].

Parameters:	look_aside : float Look this fraction of the estimated beat interval to each side of the assumed next beat position to look for the most likely position of the next beat. fps : float, optional Frames per second.

See also

BeatTrackingProcessor

Notes

A constant tempo throughout the whole piece is assumed.

Instead of the auto-correlation based method for tempo estimation proposed in [R21], it uses a comb filter based method [R22] per default. The behaviour can be controlled with the tempo_method parameter.

References

[R21]

(1, 2, 3) Sebastian Böck and Markus Schedl, “Enhanced Beat Tracking with Context-Aware Neural Networks”, Proceedings of the 14th International Conference on Digital Audio Effects (DAFx), 2011.

[R22]

(1, 2) Sebastian Böck, Florian Krebs and Gerhard Widmer, “Accurate Tempo Estimation based on Recurrent Neural Networks and Resonating Comb Filters”, Proceedings of the 16th International Society for Music Information Retrieval Conference (ISMIR), 2015.

Examples

Create a BeatDetectionProcessor. The returned array represents the positions of the beats in seconds, thus the expected sampling rate has to be given.

>>> proc = BeatDetectionProcessor(fps=100)
>>> proc  
<madmom.features.beats.BeatDetectionProcessor object at 0x...>

Call this BeatDetectionProcessor with the beat activation function returned by RNNBeatProcessor to obtain the beat positions.

>>> act = RNNBeatProcessor()('tests/data/audio/sample.wav')
>>> proc(act)
array([ 0.11,  0.45,  0.79,  1.13,  1.47,  1.81,  2.15,  2.49])

class madmom.features.beats.CRFBeatDetectionProcessor(interval_sigma=0.18, use_factors=False, num_intervals=5, factors=array([ 0.5, 0.67, 1., 1.5, 2. ]), **kwargs)[source]¶

Conditional Random Field Beat Detection.

Tracks the beats according to the previously determined global tempo using a conditional random field (CRF) model.

Parameters:	interval_sigma : float, optional Allowed deviation from the dominant beat interval per beat. use_factors : bool, optional Use dominant interval multiplied by factors instead of intervals estimated by tempo estimator. num_intervals : int, optional Maximum number of estimated intervals to try. factors : list or numpy array, optional Factors of the dominant interval to try.

References

[R24]

Filip Korzeniowski, Sebastian Böck and Gerhard Widmer, “Probabilistic Extraction of Beat Positions from a Beat Activation Function”, Proceedings of the 15th International Society for Music Information Retrieval Conference (ISMIR), 2014.

Examples

Create a CRFBeatDetectionProcessor. The returned array represents the positions of the beats in seconds, thus the expected sampling rate has to be given.

>>> proc = CRFBeatDetectionProcessor(fps=100)
>>> proc  
<madmom.features.beats.CRFBeatDetectionProcessor object at 0x...>

Call this BeatDetectionProcessor with the beat activation function returned by RNNBeatProcessor to obtain the beat positions.

>>> act = RNNBeatProcessor()('tests/data/audio/sample.wav')
>>> proc(act)
array([ 0.09,  0.79,  1.49])

process(activations)[source]¶

Detect the beats in the given activation function.

Parameters:	activations : numpy array Beat activation function.
Returns:	numpy array Detected beat positions [seconds].

static add_arguments(parser, interval_sigma=0.18, use_factors=False, num_intervals=5, factors=array([ 0.5, 0.67, 1., 1.5, 2. ]))[source]¶

Add CRFBeatDetection related arguments to an existing parser.

Parameters:

parser : argparse parser instance Existing argparse parser object. interval_sigma : float, optional allowed deviation from the dominant beat interval per beat use_factors : bool, optional use dominant interval multiplied by factors instead of intervals estimated by tempo estimator num_intervals : int, optional max number of estimated intervals to try factors : list or numpy array, optional factors of the dominant interval to try

Returns:

parser_group : argparse argument group CRF beat tracking argument parser group.

class madmom.features.beats.DBNBeatTrackingProcessor(min_bpm=55.0, max_bpm=215.0, num_tempi=None, transition_lambda=100, observation_lambda=16, correct=True, threshold=0, fps=None, **kwargs)[source]¶

Beat tracking with RNNs and a dynamic Bayesian network (DBN) approximated by a Hidden Markov Model (HMM).

Parameters:

min_bpm : float, optional Minimum tempo used for beat tracking [bpm]. max_bpm : float, optional Maximum tempo used for beat tracking [bpm]. num_tempi : int, optional Number of tempi to model; if set, limit the number of tempi and use a log spacing, otherwise a linear spacing. transition_lambda : float, optional Lambda for the exponential tempo change distribution (higher values prefer a constant tempo from one beat to the next one). observation_lambda : int, optional Split one beat period into observation_lambda parts, the first representing beat states and the remaining non-beat states. threshold : float, optional Threshold the observations before Viterbi decoding. correct : bool, optional Correct the beats (i.e. align them to the nearest peak of the beat activation function). fps : float, optional Frames per second.

Notes

Instead of the originally proposed state space and transition model for the DBN [R25], the more efficient version proposed in [R26] is used.

References

[R25]

(1, 2) Sebastian Böck, Florian Krebs and Gerhard Widmer, “A Multi-Model Approach to Beat Tracking Considering Heterogeneous Music Styles”, Proceedings of the 15th International Society for Music Information Retrieval Conference (ISMIR), 2014.

[R26]

(1, 2) Florian Krebs, Sebastian Böck and Gerhard Widmer, “An Efficient State Space Model for Joint Tempo and Meter Tracking”, Proceedings of the 16th International Society for Music Information Retrieval Conference (ISMIR), 2015.

Examples

Create a DBNBeatTrackingProcessor. The returned array represents the positions of the beats in seconds, thus the expected sampling rate has to be given.

>>> proc = DBNBeatTrackingProcessor(fps=100)
>>> proc  
<madmom.features.beats.DBNBeatTrackingProcessor object at 0x...>

Call this DBNBeatTrackingProcessor with the beat activation function returned by RNNBeatProcessor to obtain the beat positions.

>>> act = RNNBeatProcessor()('tests/data/audio/sample.wav')
>>> proc(act)
array([ 0.1 ,  0.45,  0.8 ,  1.12,  1.48,  1.8 ,  2.15,  2.49])

process(activations)[source]¶

Detect the beats in the given activation function.

Parameters:	activations : numpy array Beat activation function.
Returns:	beats : numpy array Detected beat positions [seconds].

static add_arguments(parser, min_bpm=55.0, max_bpm=215.0, num_tempi=None, transition_lambda=100, observation_lambda=16, threshold=0, correct=True)[source]¶

Add DBN related arguments to an existing parser object.

Parameters:

parser : argparse parser instance Existing argparse parser object. min_bpm : float, optional Minimum tempo used for beat tracking [bpm]. max_bpm : float, optional Maximum tempo used for beat tracking [bpm]. num_tempi : int, optional Number of tempi to model; if set, limit the number of tempi and use a log spacing, otherwise a linear spacing. transition_lambda : float, optional Lambda for the exponential tempo change distribution (higher values prefer a constant tempo over a tempo change from one beat to the next one). observation_lambda : float, optional Split one beat period into observation_lambda parts, the first representing beat states and the remaining non-beat states. threshold : float, optional Threshold the observations before Viterbi decoding. correct : bool, optional Correct the beats (i.e. align them to the nearest peak of the beat activation function).

Returns:

parser_group : argparse argument group DBN beat tracking argument parser group

class madmom.features.beats.DBNDownBeatTrackingProcessor(beats_per_bar, min_bpm=55.0, max_bpm=215.0, num_tempi=60, transition_lambda=100, observation_lambda=16, threshold=0.05, correct=True, downbeats=False, fps=None, **kwargs)[source]¶

Downbeat tracking with RNNs and a dynamic Bayesian network (DBN) approximated by a Hidden Markov Model (HMM).

Parameters:

beats_per_bar : int or list Number of beats per bar to be modeled. Can be either a single number or a list or array with bar lengths (in beats). min_bpm : float or list, optional Minimum tempo used for beat tracking [bpm]. If a list is given, each item corresponds to the number of beats per bar at the same position. max_bpm : float or list, optional Maximum tempo used for beat tracking [bpm]. If a list is given, each item corresponds to the number of beats per bar at the same position. num_tempi : int or list, optional Number of tempi to model; if set, limit the number of tempi and use a log spacing, otherwise a linear spacing. If a list is given, each item corresponds to the number of beats per bar at the same position. transition_lambda : float or list, optional Lambda for the exponential tempo change distribution (higher values prefer a constant tempo from one beat to the next one). If a list is given, each item corresponds to the number of beats per bar at the same position. observation_lambda : int, optional Split one (down-)beat period into observation_lambda parts, the first representing (down-)beat states and the remaining non-beat states. threshold : float, optional Threshold the RNN (down-)beat activations before Viterbi decoding. correct : bool, optional Correct the beats (i.e. align them to the nearest peak of the (down-)beat activation function). downbeats : bool, optional Report downbeats only, not all beats and their position inside the bar. fps : float, optional Frames per second.

References

[R27]

Sebastian Böck, Florian Krebs and Gerhard Widmer, “Joint Beat and Downbeat Tracking with Recurrent Neural Networks” Proceedings of the 17th International Society for Music Information Retrieval Conference (ISMIR), 2016.

Examples

Create a DBNDownBeatTrackingProcessor. The returned array represents the positions of the beats and their position inside the bar. The position is given in seconds, thus the expected sampling rate is needed. The position inside the bar follows the natural counting and starts at 1.

The number of beats per bar which should be modelled must be given, all other parameters (e.g. tempo range) are optional but must have the same length as beats_per_bar, i.e. must be given for each bar length.

>>> proc = DBNDownBeatTrackingProcessor(beats_per_bar=[3, 4], fps=100)
>>> proc  
<madmom.features.beats.DBNDownBeatTrackingProcessor object at 0x...>

Call this DBNDownBeatTrackingProcessor with the beat activation function returned by RNNDownBeatProcessor to obtain the beat positions.

>>> act = RNNDownBeatProcessor()('tests/data/audio/sample.wav')
>>> proc(act)  
array([[ 0.09,  1.  ],
       [ 0.45,  2.  ],
       ...,
       [ 2.14,  3.  ],
       [ 2.49,  4.  ]])

process(activations)[source]¶

Detect the beats in the given activation function.

Parameters:	activations : numpy array (down-)beat activation function.
Returns:	beats : numpy array Detected (down-)beat positions [seconds] and beat numbers.

static add_arguments(parser, beats_per_bar, min_bpm=55.0, max_bpm=215.0, num_tempi=60, transition_lambda=100, observation_lambda=16, threshold=0.05, correct=True)[source]¶

Add DBN downbeat tracking related arguments to an existing parser object.

Parameters:

parser : argparse parser instance Existing argparse parser object. beats_per_bar : int or list, optional Number of beats per bar to be modeled. Can be either a single number or a list with bar lengths (in beats). min_bpm : float or list, optional Minimum tempo used for beat tracking [bpm]. If a list is given, each item corresponds to the number of beats per bar at the same position. max_bpm : float or list, optional Maximum tempo used for beat tracking [bpm]. If a list is given, each item corresponds to the number of beats per bar at the same position. num_tempi : int or list, optional Number of tempi to model; if set, limit the number of tempi and use a log spacing, otherwise a linear spacing. If a list is given, each item corresponds to the number of beats per bar at the same position. transition_lambda : float or list, optional Lambda for the exponential tempo change distribution (higher values prefer a constant tempo over a tempo change from one beat to the next one). If a list is given, each item corresponds to the number of beats per bar at the same position. observation_lambda : float, optional Split one (down-)beat period into observation_lambda parts, the first representing (down-)beat states and the remaining non-beat states. threshold : float, optional Threshold the RNN (down-)beat activations before Viterbi decoding. correct : bool, optional Correct the beats (i.e. align them to the nearest peak of the (down-)beat activation function).

Returns:

parser_group : argparse argument group DBN downbeat tracking argument parser group

class madmom.features.beats.PatternTrackingProcessor(pattern_files, min_bpm=[55, 60], max_bpm=[205, 225], num_tempi=[None, None], transition_lambda=[100, 100], downbeats=False, fps=None, **kwargs)[source]¶

Pattern tracking with a dynamic Bayesian network (DBN) approximated by a Hidden Markov Model (HMM).

Parameters:

pattern_files : list List of files with the patterns (including the fitted GMMs and information about the number of beats). min_bpm : list, optional Minimum tempi used for pattern tracking [bpm]. max_bpm : list, optional Maximum tempi used for pattern tracking [bpm]. num_tempi : int or list, optional Number of tempi to model; if set, limit the number of tempi and use a log spacings, otherwise a linear spacings. transition_lambda : float or list, optional Lambdas for the exponential tempo change distributions (higher values prefer constant tempi from one beat to the next .one) downbeats : bool, optional Report only the downbeats instead of the beats and the respective position inside the bar. fps : float, optional Frames per second.

Notes

min_bpm, max_bpm, num_tempo_states, and transition_lambda must contain as many items as rhythmic patterns are modeled (i.e. length of pattern_files). If a single value is given for num_tempo_states and transition_lambda, this value is used for all rhythmic patterns.

Instead of the originally proposed state space and transition model for the DBN [R28], the more efficient version proposed in [R29] is used.

References

[R28]

(1, 2) Florian Krebs, Sebastian Böck and Gerhard Widmer, “Rhythmic Pattern Modeling for Beat and Downbeat Tracking in Musical Audio”, Proceedings of the 15th International Society for Music Information Retrieval Conference (ISMIR), 2013.

[R29]

(1, 2) Florian Krebs, Sebastian Böck and Gerhard Widmer, “An Efficient State Space Model for Joint Tempo and Meter Tracking”, Proceedings of the 16th International Society for Music Information Retrieval Conference (ISMIR), 2015.

Examples

Create a PatternTrackingProcessor from the given pattern files. These pattern files include fitted GMMs for the observation model of the HMM. The returned array represents the positions of the beats and their position inside the bar. The position is given in seconds, thus the expected sampling rate is needed. The position inside the bar follows the natural counting and starts at 1.

>>> from madmom.models import PATTERNS_BALLROOM
>>> proc = PatternTrackingProcessor(PATTERNS_BALLROOM, fps=50)
>>> proc  
<madmom.features.beats.PatternTrackingProcessor object at 0x...>

Call this PatternTrackingProcessor with a multi-band spectrogram to obtain the beat and downbeat positions. The parameters of the spectrogram have to correspond to those used to fit the GMMs.

>>> from madmom.processors import SequentialProcessor
>>> from madmom.audio.spectrogram import LogarithmicSpectrogramProcessor, SpectrogramDifferenceProcessor, MultiBandSpectrogramProcessor
>>> log = LogarithmicSpectrogramProcessor()
>>> diff = SpectrogramDifferenceProcessor(positive_diffs=True)
>>> mb = MultiBandSpectrogramProcessor(crossover_frequencies=[270])
>>> pre_proc = SequentialProcessor([log, diff, mb])

>>> act = pre_proc('tests/data/audio/sample.wav')
>>> proc(act)  
array([[ 0.82,  4.  ],
       [ 1.78,  1.  ],
       ...,
       [ 3.7 ,  3.  ],
       [ 4.66,  4.  ]])

process(activations)[source]¶

Detect the beats based on the given activations.

Parameters:	activations : numpy array Activations (i.e. multi-band spectral features).
Returns:	beats : numpy array Detected beat positions [seconds].

static add_arguments(parser, pattern_files=None, min_bpm=[55, 60], max_bpm=[205, 225], num_tempi=[None, None], transition_lambda=[100, 100])[source]¶

Add DBN related arguments for pattern tracking to an existing parser object.

Parameters:

parser : argparse parser instance Existing argparse parser object. pattern_files : list Load the patterns from these files. min_bpm : list, optional Minimum tempi used for beat tracking [bpm]. max_bpm : list, optional Maximum tempi used for beat tracking [bpm]. num_tempi : int or list, optional Number of tempi to model; if set, limit the number of states and use log spacings, otherwise a linear spacings. transition_lambda : float or list, optional Lambdas for the exponential tempo change distribution (higher values prefer constant tempi from one beat to the next one).

Returns:

parser_group : argparse argument group Pattern tracking argument parser group

Notes

pattern_files, min_bpm, max_bpm, num_tempi, and transition_lambda must the same number of items.