[PYTHON] Transformée de Fourier des données brutes

J'ai essayé d'analyser la transformée de Fourier discrète avec des données brutes

J'ai essayé de trouver la quantité de fonctionnalités requise pour l'apprentissage automatique en la transformant à partir de données de séries chronologiques. Il y avait des articles qui créaient et analysaient automatiquement des fonctions périodiques, mais j'ai pris le temps de comprendre comment gérer les données réelles, alors je les ai créées comme un mémorandum. Je l'ai également résumé, y compris la compréhension des concepts et des termes. Cela peut être ambigu parce que c'est une compréhension approximative. Veuillez signaler toute erreur.

Transformée de Fourier discrète (DFT)

Pour résumer brièvement la transformation de Fourier, __ Une conversion du signal périodique de données chronologiques pour la région temporelle en un spectre dans la région fréquentielle __ devenir. De plus, en appliquant une fonction de fenêtre (généralement une fenêtre bourdonnante), elle est forcément considérée comme périodique.

Transformée de Fourier rapide (FFT)

La transformation de Fourier à grande vitesse fait référence à une transformation de Fourier discrète qui peut être calculée à grande vitesse lorsque le nombre de données est la puissance de 2. Je ne comprends pas les détails des formules et des algorithmes, mais si vous avez une énorme quantité de données, vous pouvez vous attendre à améliorer la vitesse de calcul en complétant à 0 et en alignant le nombre de données sur la puissance de 2.

la mise en oeuvre

Tout d'abord, les données brutes sont soumises à la transformée de Fourier telles quelles. Ici, le fft de Numpy est utilisé. (La version Numpy est '1.18.1') https://numpy.org/doc/stable/reference/generated/numpy.fft.fft.html La FFT est une transformée de Fourier rapide, mais lorsque vous passez une valeur à numpy, elle est transformée de Fourier même si ce n'est pas une puissance de 2. En d'autres termes, on considère que la FFT est exécutée lorsque la puissance de 2 est la puissance, et la DFT est exécutée lorsqu'elle n'est pas la puissance de 2. Ces données correspondent à 30fps 1 seconde de données C'est-à-dire que les données d'échantillon 30 sont soumises à une transformée de Fourier. Cette fois, une colonne et 30 lignes d'un certain fichier csv sont traitées comme des données.

Récupération de données

#Importation des bibliothèques requises
import numpy as np
#Chargement des données
data = np.loadtxt('____.csv', delimiter=',', dtype=float)
features = data[0:30,0:1]
features[0:30,0:1]

Les 30 données que vous souhaitez analyser ont été importées dans des entités. À propos, les données des entités sont les données de tableau suivantes.

features

array([[0.32640783],[0.32772677],[0.32963271],[0.32872528],[0.33125733],[0.3250282 ],[0.33900562],[0.33105499],[0.33294834],[0.34554142],[0.33217829],[0.33006385],[0.33765947],[0.33173415],[0.33826796][0.34325231],[0.35284764],[0.34785128],[0.349527  ],[0.34782048],[0.35720176],[0.36520328],[0.37276383],[0.37766436],[0.37410199],[0.37990772],[0.38644416],[0.38045958],[0.37864619],[0.39122537]])

Nous avons procédé à la mise en œuvre en nous référant aux articles associés. Le code d'implémentation et les résultats sont les suivants.

main

#Fréquence d'échantillonnage
rate = 30 # [1/s]

#Temps d'échantillonnage[s]
t = np.arange(0, 1, 1/rate)

#signal
signal = np.ravel(features[0:30,0:1])
plt.plot(t, signal)
plt.xlim(0, 1)
plt.xlabel('time [s]', fontsize=20)
plt.title('Time series of signal', fontsize=20)
plt.show()
#print(np.ravel(signal))
# power spectrum
p = np.abs(np.fft.rfft(signal))

hammingWindow = np.hamming(30)    #Fenêtre bourdonnante
plt.plot(t, hammingWindow*signal)
plt.show()
p2 = np.abs(np.fft.rfft(hammingWindow*signal))

#Compte tenu du taux d'échantillonnage (inverse), renvoie la fréquence de chaque composant
f = np.fft.rfftfreq(signal.size, d=1./rate)
print(p)
print(np.fft.rfft(hammingWindow*signal),p2)

plt.xlabel("Frequency [Hz]", fontsize=20)
plt.ylabel("Amplitude spectrum", fontsize=20)
plt.yscale("log")
plt.plot(f, p)
plt.show()
plt.yscale("log")
plt.plot(f, p2)
plt.show()
#Transformée de Fourier Rapide
F = np.fft.fft(hammingWindow*signal)
#Calculer le spectre d'amplitude
Amp = np.abs(F)
freq = np.linspace(0, 1.0/0.03, 30) #Axe de fréquence
print(np.fft.rfft(signal))
plt.plot(freq, Amp)
plt.show()

résultat

Tout d'abord, les données (caractéristiques) dans le domaine temporel ont été représentées sous forme de graphique.

Si vous le regardez, vous pouvez voir qu'il n'y a pas de périodicité ... Puisque le but est de le mettre en œuvre, nous procéderons tel quel. De plus, une forme adaptée à une fenêtre bourdonnante qui donne de la périodicité est comme ça.

Cela ressemble à un cycle. (Parce que les bords sont alignés)

Le résultat de Fourier transformant chacun d'eux en un spectre d'amplitude est le suivant.

[10.49214916 0.35316679 0.16715576 0.10588365 0.04224876 0.08174254 0.0362962 0.03914191 0.04407553 0.07351728 0.02862219 0.05424663 0.06239112 0.03642959 0.04382539 0.01436891]

[5.44620123 2.3808305 0.0238307 0.02004583 0.03723908 0.02777476 0.00710696 0.01448964 0.00951674 0.02489049 0.01539931 0.01742193 0.01562835 0.01323487 0.01355436 0.01185119]

L'axe de gauche est un graphique logarithmique. Un spectre d'amplitude similaire a été obtenu.

Comme décrit ci-dessus, le spectre d'amplitude a été obtenu en effectuant la transformée de Fourier. Le spectre de puissance est le carré du spectre d'amplitude, donc si vous voulez le spectre de puissance, vous pouvez carré le spectre d'amplitude.

Sommaire

Ci-dessous, les termes de transformée de Fourier et de numpy étaient compliqués lors de la recherche du spectre d'amplitude, je vais donc les résumer.

np.fft.fft: renvoie le résultat de la transformation de Fourier entre les parties réelles et imaginaires np.fft.rfft: Renvoie uniquement la partie réelle (1/2 tableau de np.fft.fft)

Par conséquent, abs (np.fft.fft) et abs (np.fft.rfft) ont la même taille mais des longueurs de retour différentes. np.fft.rfft est la moitié de np.fft.fft. Ce n'est pas nécessaire car il s'agit d'une relation conjuguée complexe.

Transformée de Fourier et python

F (w) = np.fft.fft (w): Spectre de Fourier (transformée de Fourier)

|F(w)| = np.abs(F(w)): Spectre d'oscillation(F(w)Valeur absolue de)

|F(w)|^2: spectre de puissance[F(w)*(F(w)Nombre complexe conjugué de)], Carré du spectre d'amplitude, puissance(Puissance)Avoir la dimension de

Analyse Excel

En fait, l'analyse de Fourier est installée dans l'outil d'analyse de données d'Excel. Quand j'ai vérifié si c'était la même chose que numpy, la même partie réelle et la même partie imaginaire que np.fft.fft ont été renvoyées. Cela peut être mieux lorsqu'il est difficile de programmer. Cependant, les valeurs sont mélangées entre la partie réelle et la partie imaginaire, et un nouveau calcul est nécessaire pour obtenir le spectre d'amplitude. Notez également que dans Excel, le nombre de données ne peut être exécuté que s'il s'agit d'une puissance de 2.

Transformée de Fourier inverse

On peut considérer que la composante basse fréquence forme un grand contour dans la forme du graphique, et la composante haute fréquence est bruyante. Il a été vu lors d'une recherche documentaire. Par conséquent, si seul le spectre de la composante basse fréquence 0 Hz à 2 Hz résultant de la conversion de Fourier est inversement transformé de Fourier, J'ai pensé que je pouvais dessiner un graphique proche des données d'origine, alors je l'ai implémenté. Les trois premières données de ce qui a été ajouté précédemment sont laissées telles quelles, et les autres sont mises à 0.

irfft

plt.plot(t, np.fft.irfft([1.04921492e+01+0.j,8.98589353e-02+0.34154378j,-6.04938542e-02+0.15582535j,0,0,0,0,0,0,0,0,0,0,0,0,0]))
plt.show()

résultat

Il a une forme similaire par rapport au graphique des données d'origine. On peut donc dire qu'elle pourrait être reproduite (les caractéristiques pourraient être extraites par la composante fréquentielle).

Références

https://ja.wikipedia.org/wiki/離散フーリエ変換 https://numpy.org/doc/stable/reference/generated/numpy.fft.fft.html https://kyotogeopython.zawawahoge.com/html/基礎編/Numpyの基礎（７）便利なライブラリ群.html https://aidiary.hatenablog.com/entry/20110716/1310824587 https://www.geidai.ac.jp/~marui/r_program/spectrum.html