STFT et DWT (ondelettes)

STFT peut être utilisé avec succès sur des données sonores (avec un fichier son .wav par exemple) afin de faire quelques modifications dans le domaine fréquentiel (exemple: suppression du bruit).
Avec N=441000( à savoir 10 secondes à la fréquence d' échantillonnage fs=44100), windowsize=4096, overlap=4, STFT produit approximativement une 430x4096matrice (première coordonnée: laps de temps, secondes coordonnées: bin de fréquence). Des modifications peuvent être effectuées sur ce tableau, et la reconstruction peut être effectuée avec overlap-add (*).

Comment est-il possible de faire une chose similaire avec des ondelettes ? (DWT), c'est-à-dire obtenir un tableau de forme similaire a x b, avec des adélais et des intervalles de bfréquence, faire quelques modifications sur ce tableau et, à la fin, récupérer un signal? Comment ? Quel est l'ondelette équivalente à chevauchement-ajout ? Quelles seraient les fonctions Python impliquées ici (je n'ai pas trouvé d'exemple simple de modification audio avec pyWavelets...)?

(*): Voici le framework STFT qui peut être utilisé:

signal = stft.Stft(x, 4096, 4)    # x is the input
modified_signal = np.zeros(signal.shape, dtype=np.complex)

for i in xrange(signal.shape[0]):    # Process each STFT frame
    modified_signal[i, :] =  signal[i, :] * .....  # here do something in order to
                                                   # modify the signal in frequency domain !
y = stft.OverlapAdd(modified_signal, 4)   # y is the output

Le but est de trouver un cadre similaire avec des ondelettes.

— Basj
source

Un commentaire secondaire: faire ce genre de "filtrage" sur le STFT est une très mauvaise idée. Ce n'est pas un excellent moyen de faire la plupart des choses que vous voulez vraiment faire. Qu'essayez-vous réellement de réaliser?

— Peter K.

Notez que PyWavelets est uniquement pour la transformation en ondelettes discrète. Si vous voulez faire des trucs de type STFT, vous comprendrez plus facilement la transformation en ondelettes continue, comme la transformation Q constante, qui est une transformation de Gabor, essentiellement la même chose qu'une transformation en ondelettes continue Morlet complexe , mais est conçue pour être inversible: grrrr.org/research/software/nsgt

— endolith

(cette question relancée par "Communauté".) à mon avis, les ondelettes se chevauchent et s'ajoutent d'une manière très similaire à STFT. donc je ne comprends pas très bien la nature de la question.

— robert bristow-johnson

Faut-il plus de détails?

— Laurent Duval

Réponses:

La transformée de Fourier à court terme est généralement une transformation redondante, généralement implémentée avec le même sous-échantillonnage sur chaque fréquence. Si la fenêtre est bien choisie, elle est complète: vous pouvez l'inverser et récupérer n'importe quel signal initial.

Puisqu'il est redondant et complet, il a de nombreux inverses parfaits. Il peut être implémenté et compris à l'aide d'outils plus génériques: des banques de filtres complexes (suréchantillonnées). Étant donné un type et une longueur de fenêtre plus le chevauchement, vous disposez d'une banque de filtres d'analyse pour laquelle vous pouvez calculer si elle est inversible ou non. Si c'est le cas, vous pouvez également calculer un inverse naturel et des inverses optimisés . L'ajout de chevauchement n'est qu'un des nombreux inverses potentiels, probablement les plus courants, ce qui limite souvent le choix de la fenêtre.

Les transformées en ondelettes discrètes standard sont également des banques de filtres, à la différence que le sous-échantillonnage n'est pas le même dans chaque bande de fréquence (ou plus correctement à l'échelle). Cela se transforme en longueurs inégales pour chaque échelle. Pourtant, il existe des implémentations d'ondelettes redondantes qui produisent "un tableau rectangle" de coefficients avec lesquels vous pouvez travailler. Les schémas les plus connus sont appelés sous différents noms: ondelettes invariantes au décalage ou invariantes dans le temps , ondelettes non décimées, transformée en ondelettes stationnaire(SWT), et parfois cycle-spinning. Sa reconstruction standard implique des étapes similaires à l'ajout-chevauchement, sauf qu'elles sont plus "intégrées" en raison des différents facteurs d'échantillonnage sur les échelles. Vous pouvez les utiliser avec n'importe quelle ondelette discrète d'une bibliothèque, ou même en concevant votre propre ondelette. La raison en est que les ondelettes discrètes standard ont été conçues dans un souci de non-redondance, ce qui restreint le choix des ondelettes. Avec la redondance, votre choix d'ondelettes augmente, car les contraintes à remplir sont moins strictes. L'avatar "ultime" est la transformée en ondelettes continue, qui admet "presque" toutes les ondelettes de synthèse inverse. Ma dernière phrase est assez moche, j'espère que vous comprenez: quand une matrice carrée est inversible, elle n'a qu'un inverse. Lorsqu'une matrice "rectangulaire" est inversible à gauche de manière généralisée,

Il semble y avoir une implémentation python de la transformation stationnaire en ondelettes . Vous pouvez trouver quelques références dans le 2.3.4. Chapitre ondelettes invariantes de traduction du papier lié .

Il est généralement beaucoup plus robuste pour la détection, le débruitage ou la restauration dans des applications pratiques (géophysique, essais non destructifs, ultrasons, vibrations).

— Laurent Duval
source

"Redondant" signifie "a plus d'informations dans la sortie que nécessaire pour reproduire l'entrée"?

— endolith

N

$N$

M > N

$M> N$

La raison pour laquelle vous avez besoin de chevauchement ajouter / chevaucher enregistrer pour filtrer avec la transformée de Fourier à court terme est essentiellement que les fonctions de base associées aux coefficients que vous obtenez sont définies sur une certaine plage de temps (par opposition à un seul point dans le temps). La transformée de Fourier que vous utilisez pour calculer les coefficients d'expansion implémente également la convolution sur un domaine circulaire défini par la longueur de votre trame de signal. Cela signifie que les deux points d'extrémité du cadre sont vraiment identifiés et fermés en cercle. C'est pourquoi vous devez vous assurer que les fonctions de base des coefficients que vous modifiez n'affectent jamais les deux extrémités du cadre en les entourant.

Les ondelettes ne sont ni des vecteurs propres de traduction temporelle ni calculées par convolution circulaire. Cela signifie que vous n'avez pas besoin d'ajout ou d'enregistrement de chevauchement ni d'aucune autre méthode traitant des effets secondaires de la convolution circulaire. Au lieu de cela, les vecteurs de base d'ondelettes ne sont qu'une base possible pour décrire votre signal. La transformée en ondelettes (complète, discrète, éventuellement orthogonale) n'est donc rien d'autre qu'un changement de base de la base du domaine temporel à la base du domaine des ondelettes. Les changements de base peuvent être inversés (en appliquant l'inverse de la matrice de changement de base qui vous y a amené) et vous pouvez revenir au domaine temporel.

Les paramètres que vous avez donnés comme taille de fenêtre, chevauchement, taux d'échantillonnage ne sont pas tous applicables à la transformée en ondelettes. La seule chose dont vous avez besoin est une ondelette mère. Si vous souhaitez comparer les résultats à votre sortie STFT, vous pouvez choisir l'un des vecteurs de base STFT (c'est-à-dire votre fenêtre multipliée par une porteuse exponentielle complexe) comme prototype d'ondelettes. Ensuite, vous appliquez la transformée en ondelettes rapide, qui décomposera votre signal en un arbre de signaux filtrés et décimés passe-haut et passe-bas qui deviendront finalement vos coefficients. Chaque coefficient est associé à un vecteur de base d'ondelettes et à ses paramètres (échelle, temps) ou (fréquence, temps). Vous pouvez manipuler les coefficients, puis appliquer la transformée en ondelettes discrète inverse. Il prendra vos coefficients et les exécutera à travers une banque de filtres de resynthèse pour produire à nouveau un signal.

Ces processus ne sont pas triviaux et peuvent être difficiles à digérer pour un débutant. Mais vous devriez pouvoir trouver des bibliothèques / boîtes à outils pour votre plate-forme de choix qui implémentent la transformée en ondelettes rapide et son inverse. Cependant, si vous souhaitez réaliser votre propre base d'ondelettes, vous devrez dériver les coefficients de filtre pour les banques de filtres de décomposition et de synthèse. Cela nécessite une théorie profonde, et vous devrez probablement l'étudier en premier.

Il existe d'autres saveurs de la transformée en ondelettes, à savoir la transformée en ondelettes continue qui fonctionne avec une base trop complète. Il est à la fois beaucoup plus lent à calculer et beaucoup plus difficile à inverser, de sorte que ce n'est pas actuellement une option pour ce que vous voulez faire.

— Jazzmaniac
source

Merci pour votre réponse. La principale raison pour laquelle j'essaie d'avoir un cadre de code est que j'ai toujours remarqué (de mon enfance à il y a quelques années quand j'ai terminé mon doctorat (pas lié au DSP bien sûr, si c'est le cas, je ne demanderais pas donc les questions pour les débutants ici!)) est que la manipulation de matériel réel (par exemple le signal audio dans DSP) aide beaucoup à comprendre la théorie profonde. Ce que je voudrais le code est: Audio sound -> Wavelet transform -> (do something on the array) -> Inversion -> Audio output. Avec beaucoup de (faire quelque chose sur le tableau), je suis sûr que je comprendrai un peu plus le fonctionnement des ondelettes.

— Basj

@Basj, alors fais ce que j'ai dit. Trouvez une bibliothèque python qui prend en charge à la fois la transformée en ondelettes rapide et son inverse, puis jouez avec l'arbre des coefficients généré. Bonne chance et amusez-vous bien!

— Jazzmaniac

"ne sont pas tous applicables à la transformée en ondelettes" Ils sont applicables à CWT, non?

— endolith

Il existe de nombreuses façons de définir une base d'ondelettes. Typiquement, une ondelette ressemble à:

w_{x_{0}, k_{0}} (x) = A \exp (i k_{0} x) e (k_{0} (x - x_{0}))

$w_{x_0,k_0}(x) = A\exp(ik_0x)e(k_0(x-x_0))$

$x_0$ $k_0$ $e$ $A$ $k$

$(x_0,k_0)$ $(x_0,k_0)$

Étant donné que la dimensionnalité des données transformées dépasse celle du signal, la base d'ondelettes ne sera pas orthonormée. C'est-à-dire que ce qui suit sera faux:

⟨ w_{k_{0}, x_{0}} | w_{k_{0}^{'}, x_{0}^{'}} ⟩ = δ (x_{0}, x_{0}^{'}) δ (k_{0}, k_{0}^{'})

$\left\langle w_{k_0, x_0} | w_{k_0',x_0'} \right\rangle = \delta(x_0,x_0')\delta(k_0,k_0')$

$A$ $w$

\sum_{x_{0}, k_{0}} | w_{x_{0}, k_{0}} ⟩ \frac{1}{\sqrt{k_{0}}} ⟨ w_{x_{0}, k_{0}} | = identity

$\sum_{x_0,k_0} \left| w_{x_0,k_0} \right\rangle \frac{1}{\sqrt{k_0}} \left\langle w_{x_0,k_0} \right| = \text{identity}$

En d'autres termes, vous pouvez reconstruire parfaitement le signal simplement en additionnant ses ondelettes constitutives.

Votre "modification" peut simplement être insérée dans la somme ci-dessus:

my_filter = \sum_{x_{0}, k_{0}} | w_{x_{0}, k_{0}} ⟩ f (x_{0}, k_{0}) ⟨ w_{x_{0}, k_{0}} |

$\text{my_filter} = \sum_{x_0,k_0} \left| w_{x_0,k_0} \right\rangle f(x_0,k_0) \left\langle w_{x_0,k_0} \right|$

Mise à jour 2013-11-19: ajout de détails d'implémentation ci-dessous comme demandé.

$f(x)$

c_{x_{0}, k_{0}} = ⟨ w_{x_{0}, k_{0}} | f ⟩

$c_{x_0,k_0} = \left\langle w_{x_0,k_0} | f \right\rangle$

$k_0$ $c{x_0,k_0}$ $x_0$ $f$ $f$ $w_{0,k_0}$ $c_{x_0,k_0}$

$f$ $\hat f$ . Vous voulez probablement le faire une fenêtre à la fois, avec suffisamment de chevauchement pour pouvoir jeter les artefacts de fenêtrage, etc., mais pour simplifier, supposons que vous fassiez tout le signal en même temps et que sa longueur soit une puissance de deux.
- $\hat f$ $\hat w_{0,k_0}$
- $[k_l,k_r)$ $\hat w_{0,k_0}$
- Appliquez-y une transformée de Fourier inverse.
- $exp(ix\frac{k_l+k_r}{2})$ $c_{x_0,k_0}$ $x_0$

$k_0$ $x_0$ $w_{0,k_0}$ $k_0$ $k_0$ valeur à une résolution temporelle beaucoup plus faible. Cela fonctionne à peu près de la même manière que STFT - peut-être plus lent par un petit facteur qui dépend de la résolution que vous choisissez.

$c_{x_0,k_0}$ $k_0$

La troncature des spectres introduit parfois des problèmes de normalisation, selon précisément la façon dont votre FFT est définie. Je n'essaierai pas de couvrir toutes les possibilités ici. La normalisation est fondamentalement un problème facile. ;-)

$\hat w_{x_0,k_0}(k)$ $w_{x_0,k_0}(x)$

{\hat{w}}_{x 0, k 0} = A e x p (- i (k - k_{0}) x_{0}) e x p (- (Q l o g (k / k_{0}))^{2})

$\hat w_{x0,k0} = A exp(-i(k-k_0)x_0) exp(-(Q log(k/k_0))^2)$

$Q$ $A$ $k_0$

— apt1002
source

Merci de rappeler ces points importants sur la théorie des ondelettes, qui sont en effet nécessaires pour comprendre comment cela fonctionne. Mais ici, la question serait plutôt de construire un code cadre qui fonctionnerait sur le signal audio par exemple. Les questions sont: comment gérer ces sommes infinies, comment choisir les fenêtres (ou plutôt la mère-ondelette ), comment le faire en utilisant pyWavelets en Python (ou un autre langage équivalent, je vais traduire en Python alors), comment choisir les paramètres (comme dans mon exemple pour l'audio: taux d'échantillonnage = 44100, fenêtre fft = 4096, chevauchement = 4, etc.)

— Basj

a_{k}

$a_k$

\sum_{k} | k ⟩ a_{k} ⟨ k | = I d

$\sum_k \left| k \rangle a_k \langle k \right| = \mathrm{Id}$

K

$K$

a_{k}

$a_k$

a_{k}

$a_k$

f

$f$

La meilleure façon de voir si ça marche ou pas serait de fournir un exemple de code minimal (avec pyWavelet par exemple ça devrait être possible en quelques lignes j'imagine) (je le ferai bien une fois que je le comprendrai, je pense que je besoin de quelques jours de plus sur les ondelettes!)

— Basj