Features | latest | spectral-kurtosis

Spectral kurtosis

Spectral kurtosis is a measure of the "tailedness" or peakedness of the power spectrum around its mean, the spectral centroid $f_{centroid}$. It indicates how much of the spectrum's power is concentrated in the tails of the distribution compared to the center:

• High kurtosis: Indicates a spectrum with heavy tails and a sharp peak (leptokurtic), where spectral energy is concentrated in a few dominant frequencies far from the mean.
• Low kurtosis: Indicates a flatter spectrum (platykurtic), where spectral energy is more evenly distributed across frequencies.
• Normal kurtosis: A kurtosis value of 3 corresponds to a normal distribution (mesokurtic).

Spectral kurtosis is computed from the power spectrum $X_p=|X{|}^2\in {\mathbb{R}}^M$ using the following formula:

$$\text{SpectralKurtosis}=\frac{m_4}{m_2^2},$$

where:

• $m_k$ is the $k$-th central moment of the spectrum:

  $$m_k=\sum _{m=0}^{M-1}(f(m)-f_{centroid}{)}^k\cdot p(m),$$

• $f(m)$ is the frequency corresponding to bin $m$:

  $$f(m)=\frac{m\cdot f_s}{2(M-1)},$$

• $p(m)$ is the normalized power at bin $m$:

  $$p(m)=\frac{X_p[m]}{\sum _{k=0}^{M-1}{X}_p[k]}.$$

References

• https://www.mathworks.com/help/signal/ref/spectralkurtosis.html
• Peeters, G. (2004). A large set of audio features for sound description (similarity and classification) in the CUIDADO project. In CUIDADO IST Project Report (Vol. 54).

Code

INFO

The following snippet is written in a generic and unoptimized manner. The code aims to be comprehensible to programmers familiar with various programming languages and may not represent the most efficient or idiomatic Python practices. Please refer to implementations for optimized implementations in different programming languages.

code.py

import numpy as np


def _spectral_centroid(spectrum: np.ndarray, samplerate: float):
    ps = np.abs(spectrum) ** 2
    ps_sum = 0.0
    ps_sum_weighted = 0.0
    for i, magnitude in enumerate(ps):
        ps_sum += magnitude
        ps_sum_weighted += magnitude * i
    return 0.5 * samplerate / (len(ps) - 1) * (ps_sum_weighted / ps_sum)


def spectral_kurtosis(spectrum: np.ndarray, samplerate: float):
    f_centroid = _spectral_centroid(spectrum, samplerate)
    ps = np.abs(spectrum) ** 2
    ps_sum = 0.0
    ps_sum_weighted_2 = 0.0
    ps_sum_weighted_4 = 0.0
    for i, magnitude in enumerate(ps):
        f = 0.5 * samplerate / (len(ps) - 1) * i
        ps_sum += magnitude
        ps_sum_weighted_2 += magnitude * (f - f_centroid) ** 2
        ps_sum_weighted_4 += magnitude * (f - f_centroid) ** 4
    return (ps_sum_weighted_4 / ps_sum) / np.sqrt(ps_sum_weighted_2 / ps_sum) ** 4

Run in playground