Numpy Racine Quadratique Moyenne (RMS) de lissage d'un signal

J'ai un signal de electromyographical de données que je suis censé (articles scientifiques' recommandation explicite) pour lisser à l'aide de RMS.

J'ai le texte suivant code de travail, la production de la sortie souhaitée, mais il est beaucoup plus lent que je pense que c'est possible.

#!/usr/bin/python
import numpy
def rms(interval, halfwindow):
    """ performs the moving-window smoothing of a signal using RMS """
    n = len(interval)
    rms_signal = numpy.zeros(n)
    for i in range(n):
        small_index = max(0, i - halfwindow)  # intended to avoid boundary effect
        big_index = min(n, i + halfwindow)    # intended to avoid boundary effect
        window_samples = interval[small_index:big_index]

        # here is the RMS of the window, being attributed to rms_signal 'i'th sample:
        rms_signal[i] = sqrt(sum([s**2 for s in window_samples])/len(window_samples))

    return rms_signal

J'ai vu certains deque et itertools suggestions quant à l'optimisation de déplacement de la fenêtre de boucles, et aussi convolve de numpy, mais je ne pouvais pas comprendre comment accomplir ce que je veux utiliser.

Aussi, je ne m'inquiète pas pour éviter les problèmes de délimitation plus, parce que je finis par avoir de grands tableaux et relativement petites fenêtres coulissantes.

Merci pour la lecture

Pouvez-vous le lien vers le papier? Je n'ai jamais entendu parler de lissage d'un signal par le calcul de la valeur RMS de la pointe sur une fenêtre mobile. En général, ce ne sera pas ressembler à une version lissée de l'origine du signal.
Le lissage de cette façon est suggéré parce qu'il est en corrélation avec le signal de puissance (énergie), ce qui pourrait être utilisée pour déduire les muscles à l'effort. Lien: isek-online.org/standards_emg.html "une Autre méthode acceptable de fournir de l'amplitude de l'information est le "Root Mean Square" ou RMS. Tout comme la moyenne mobile, cette quantité est définie pour un intervalle de temps spécifique (le déplacement de la fenêtre) T qui doit être indiqué." Il est le premier choix pour le lissage selon Noraxon livret (à code source fermé, propriété de mon entreprise) avec une fenêtre de temps entre 50 et 100 ms plus ou moins.
RMS d'un déplacement de la fenêtre est l'idée derrière les compteurs audio, trop.

OriginalL'auteur heltonbiker | 2011-11-23

  1. 12

    Il est possible d'utiliser la convolution pour effectuer l'opération que vous faites allusion. Je l'ai fait à quelques reprises pour le traitement des signaux EEG.

    import numpy as np
def window_rms(a, window_size):
  a2 = np.power(a,2)
  window = np.ones(window_size)/float(window_size)
  return np.sqrt(np.convolve(a2, window, 'valid'))

    De le décomposer, le np.power(a, 2) partie fait un nouveau tableau avec la même dimension que a, mais où chaque valeur est élevée au carré. np.ones(window_size)/float(window_size) produit un tableau ou de la longueur window_size où chaque élément est 1/window_size. Donc le produit de convolution effectivement produit un nouveau tableau où chaque élément i est égal à 

    (a[i]^2 + a[i+1]^2 + … + a[i+window_size]^2)/window_size

    qui est la valeur efficace des éléments du tableau à l'intérieur de la fenêtre mobile. Il doit procéder à vraiment bien de cette façon.

    Noter, cependant, que np.power(a, 2) produit un nouveau tableau de même dimension. Si a est vraiment grand, je veux dire suffisamment grand qu'il ne tient pas deux fois dans la mémoire, vous pourriez avoir besoin d'une stratégie où chaque élément sont modifiés. Aussi, le 'valid' argument spécifie à jeter les effets de la frontière, résultant en une plus petite table produite par np.convolve(). Vous pouvez garder tout en spécifiant 'same' à la place (voir la documentation).

    Grand, grand, grand, très intelligent! Les signaux EMG sont plus courts que les EMG, moins de 50 mo pour 4 canaux d'enregistrement, de sorte que l'utilisation de la mémoire ne sera pas prohibitif. Et j'ai l'intention d'utiliser 'same', pour l'affichage dans la pile avec raw/lissé/signal filtré.
    Juste pour mémoire, RMS est 500 fois plus rapide (0.002 vs 1.000 s pour window_size' of 16 samples as measured by cProfile'), et ne pas obtenir beaucoup plus lent de façon plus grande (+de 100) de windows. Ai-je dis qu'il est grand?
    Heureux d'entendre cela!
    Vous ne devriez jamais vous ne spécifiez rien d'autres que les "valides" à l'aide du code que vous avez depuis le deuxième argument de np.convolve() contient l'inverse de la pleine longueur de la fenêtre.
    Juste pour prolonger encore un peu, il est possible d'avoir window un noyau dont la somme est 1.0, comme normalisée noyau gaussien, si certains plus ésotériques de comportement est nécessaire. En fait, les trois lignes de code dans la fonction exécuter ce que certains DSP textes génériquement appel "delinearization", "démodulation" et "relinearization", ce qui peut être fait avec des puissances différentes (en plus de deux), le noyau (d'ailleurs unitaire carré ou gaussienne), statistique de l'opérateur (en plus de la moyenne pondérée) et la taille de la fenêtre.

    OriginalL'auteur matehat

  2. 1

    Puisque ce n'est pas une transformation linéaire, je ne crois pas qu'il est possible d'utiliser des np.de convolution().

    Voici une fonction qui devrait faire ce que vous voulez. Notez que le premier élément du tableau renvoyé est la valeur rms de la première fenêtre; c'est à dire pour le tableau a dans l'exemple, le retour de la matrice est de la valeur rms de la plusieurs fenêtres [1,2],[2,3],[3,4],[4,5] et ne comprend pas l'partielle windows [1] et [5].

    >>> def window_rms(a, window_size=2):
>>>     return np.sqrt(sum([a[window_size-i-1:len(a)-i]**2 for i in range(window_size-1)])/window_size)
>>> a = np.array([1,2,3,4,5])
>>> window_rms(a)
array([ 1.41421356,  2.44948974,  3.46410162,  4.47213595])
    possible d'utiliser la convolution, voir ma réponse.

    OriginalL'auteur user545424