# spectralEntropy

Spectral entropy for audio signals and auditory spectrograms

## Syntax

``entropy = spectralEntropy(x,f)``
``entropy = spectralEntropy(x,f,Name,Value)``

## Description

example

````entropy = spectralEntropy(x,f)` returns the spectral entropy of the signal, `x`, over time. How the function interprets `x` depends on the shape of `f`.```

example

````entropy = spectralEntropy(x,f,Name,Value)` specifies options using one or more `Name,Value` pair arguments.```

## Examples

collapse all

Read in an audio file, calculate the entropy using default parameters, and then plot the results.

```[audioIn,fs] = audioread('Counting-16-44p1-mono-15secs.wav'); entropy = spectralEntropy(audioIn,fs); t = linspace(0,size(audioIn,1)/fs,size(entropy,1)); plot(t,entropy) xlabel('Time (s)') ylabel('Entropy')```

Read in an audio file and then calculate the mel spectrogram using the `melSpectrogram` function.

```[audioIn,fs] = audioread('Counting-16-44p1-mono-15secs.wav'); [s,cf,t] = melSpectrogram(audioIn,fs);```

Calculate the entropy of the mel spectrogram over time. Plot the results.

```entropy = spectralEntropy(s,cf); plot(t,entropy) xlabel('Time (s)') ylabel('Entropy')```

`[audioIn,fs] = audioread('Counting-16-44p1-mono-15secs.wav');`

Calculate the entropy of the power spectrum over time. Calculate the entropy for 50 ms Hamming windows of data with 25 ms overlap. Use the range from 62.5 Hz to `fs`/2 for the entropy calculation. Plot the results.

```entropy = spectralEntropy(audioIn,fs, ... 'Window',hamming(round(0.05*fs)), ... 'OverlapLength',round(0.025*fs), ... 'Range',[62.5,fs/2]); t = linspace(0,size(audioIn,1)/fs,size(entropy,1)); plot(t,entropy) xlabel('Time (s)') ylabel('Entropy')```

Create a `dsp.AudioFileReader` object to read in audio data frame-by-frame. Create a `dsp.SignalSink` to log the spectral entropy calculation.

```fileReader = dsp.AudioFileReader('Counting-16-44p1-mono-15secs.wav'); logger = dsp.SignalSink;```

In an audio stream loop:

1. Read in a frame of audio data.

2. Calculate the spectral entropy for the frame of audio.

3. Log the spectral entropy for later plotting.

To calculate the spectral entropy for only a given input frame, specify a window with the same number of samples as the input, and set the overlap length to zero. Plot the logged data.

```while ~isDone(fileReader) audioIn = fileReader(); entropy = spectralEntropy(audioIn,fileReader.SampleRate, ... 'Window',hamming(size(audioIn,1)), ... 'OverlapLength',0); logger(entropy) end plot(logger.Buffer) ylabel('Entropy')```

Use `dsp.AsyncBuffer` if

• The input to your audio stream loop has a variable samples-per-frame.

• The input to your audio stream loop has an inconsistent samples-per-frame with the analysis window of `spectralEntropy`.

• You want to calculate the spectral entropy for overlapped data.

Create a `dsp.AsyncBuffer` object, reset the logger, and release the file reader.

```buff = dsp.AsyncBuffer; reset(logger) release(fileReader)```

Specify that the spectral entropy is calculated for 50 ms frames with a 25 ms overlap.

```fs = fileReader.SampleRate; samplesPerFrame = round(fs*0.05); samplesOverlap = round(fs*0.025); samplesPerHop = samplesPerFrame - samplesOverlap; win = hamming(samplesPerFrame); while ~isDone(fileReader) audioIn = fileReader(); write(buff,audioIn); while buff.NumUnreadSamples >= samplesPerHop audioBuffered = read(buff,samplesPerFrame,samplesOverlap); entropy = spectralEntropy(audioBuffered,fs, ... 'Window',win, ... 'OverlapLength',0); logger(entropy) end end release(fileReader)```

Plot the logged data.

```plot(logger.Buffer) ylabel('Entropy')```

## Input Arguments

collapse all

Input signal, specified as a vector, matrix, or 3-D array. How the function interprets `x` depends on the shape of `f`.

Data Types: `single` | `double`

Sample rate or frequency vector in Hz, specified as a scalar or vector, respectively. How the function interprets `x` depends on the shape of `f`:

• If `f` is a scalar, `x` is interpreted as a time-domain signal, and `f` is interpreted as the sample rate. In this case, `x` must be a real vector or matrix. If `x` is specified as a matrix, the columns are interpreted as individual channels.

• If `f` is a vector, `x` is interpreted as a frequency-domain signal, and `f` is interpreted as the frequencies, in Hz, corresponding to the rows of `x`. In this case, `x` must be a real L-by-M-by-N array, where L is the number of spectral values at given frequencies of `f`, M is the number of individual spectra, and N is the number of channels.

• The number of rows of `x`, L, must be equal to the number of elements of `f`.

Data Types: `single` | `double`

### Name-Value Arguments

Specify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside quotes. You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

Example: `'Window',hamming(256)`

Note

The following name-value pair arguments apply if `x` is a time-domain signal. If `x` is a frequency-domain signal, name-value pair arguments are ignored.

Window applied in the time domain, specified as the comma-separated pair consisting of `'Window'` and a real vector. The number of elements in the vector must be in the range [1, `size(x,1)`]. The number of elements in the vector must also be greater than `OverlapLength`.

Data Types: `single` | `double`

Number of samples overlapped between adjacent windows, specified as the comma-separated pair consisting of `'OverlapLength'` and an integer in the range [0, `size(Window,1)`).

Data Types: `single` | `double`

Number of bins used to calculate the DFT of windowed input samples, specified as the comma-separated pair consisting of `'FFTLength'` and a positive scalar integer. If unspecified, `FFTLength` defaults to the number of elements in the `Window`.

Data Types: `single` | `double`

Frequency range in Hz, specified as the comma-separated pair consisting of `'Range'` and a two-element row vector of increasing real values in the range [0, `f`/2].

Data Types: `single` | `double`

Spectrum type, specified as the comma-separated pair consisting of `'SpectrumType'` and `'power'` or `'magnitude'`:

• `'power'` –– The spectral entropy is calculated for the one-sided power spectrum.

• `'magnitude'` –– The spectral entropy is calculated for the one-sided magnitude spectrum.

Data Types: `char` | `string`

## Output Arguments

collapse all

Spectral entropy, returned as a scalar, vector, or matrix. Each row of `entropy` corresponds to the spectral entropy of a window of `x`. Each column of `entropy` corresponds to an independent channel.

## Algorithms

The spectral entropy is calculated as described in [1]:

`$\text{entropy}=\frac{-\sum _{k={b}_{1}}^{{b}_{2}}{s}_{k}\mathrm{log}\left({s}_{k}\right)}{\mathrm{log}\left({b}_{2}-{b}_{1}\right)}$`

where

• sk is the spectral value at bin k.

• b1 and b2 are the band edges, in bins, over which to calculate the spectral entropy.

## References

[1] Misra, H., S. Ikbal, H. Bourlard, and H. Hermansky. "Spectral Entropy Based Feature for Robust ASR." 2004 IEEE International Conference on Acoustics, Speech, and Signal Processing.