【Scipy】FFT、STFTとwavelet変換で遊んでみた♬～②不確定原理について～

今夜は予定通り、「FFT、STFT、そしてWavelet変換における②不確定性原理」について実際の計算を通して考える。
###とりあえずの目標
以下のとおり、
※リンクされているものは記事にしたものであり、その記事を前提知識として書いて行くので、参照すると理解し易いと思います。
①[Scipy環境を作る](https://qiita.com/MuAuan/items/8850e037babcff991b8e)
　・環境の確認
②不確定原理について
 ・FFT変換・逆変換してみる；時間軸が消える
 ・STFT変換・逆変換してみる；窓関数について
 ・wavelet変換・逆変換してみる；スペクトログラムの解釈と不確定原理
③音声や地震データや株価や、。。。とにかく一次元の実時系列データに応用する
④FFTからwavelet変換まで簡単にたどってみる（上記以外のちょっと理論）
⑤二次元データに応用してみる
⑥天体観測データに応用してみる
⑦リアルタイムにスペクトログラムしてみる
###今回やったこと
②不確定原理について
 ・FFT変換・逆変換してみる；時間軸が消える
 ・STFT変換・逆変換してみる；窓関数について
 ・wavelet変換・逆変換してみる；スペクトログラムの解釈と不確定原理
### ・FFT変換・逆変換してみる；時間軸が消える
今回の入力の波形は、一定時間ごとにシステマティックに周期が変化するものを使う。
FFTに関しては、時間軸全体で積分してしまうので、当然ながら周波数の時間的な変化は出ない。

コードは以下のとおり

```py
from scipy.fftpack import fft, ifft
import numpy as np
import matplotlib.pyplot as plt
```
以下のように時間的に変化する関数を使う。

```py
t = np.linspace(0, 100, 1000, endpoint=False)
sig=[]
for t1 in t:
    if t1<20:
        sig1 = np.cos(2 * np.pi * 0.5 * t1)
        print("5",t1)
    elif t1<40:
        sig1 = np.cos(2 * np.pi * 1 * t1)
        print("10",t1)
    elif t1<60:
        sig1 = np.cos(2 * np.pi * 1.5 * t1)
        print("20",t1)
    elif t1<80:
        sig1 = np.cos(2 * np.pi * 2 * t1)
        print("30",t1)
    else:
        sig1 = np.cos(2 * np.pi * 2.5 * t1)
        print(t1)
    sig.append(sig1)
        
plt.plot(t, sig)
plt.axis([0, 100, -2, 2])
plt.show()
```
絵でかくと以下のように変化する。
![Figure_changeWave.png](https://qiita-image-store.s3.amazonaws.com/0/233744/9a97485d-ec2c-53c8-4144-beaf08f72f1b.png)

これを以下のようにFFTすると、当然ながら入力波形の周波数（50，100，150，200，250）のところにピークが出現する。

```py
freq =fft(sig,1024)
Pyy = np.sqrt(freq*freq.conj())/1025 #np.abs(freq)/1025    
f = np.arange(1024)
plt.plot(f,Pyy)
plt.axis([0, 512, 0, 0.2])
plt.show()
```
![Figure_FFT.png](https://qiita-image-store.s3.amazonaws.com/0/233744/1b251f2f-3215-47ab-efed-2cf5fb8ebd52.png)
そして、逆FFTを行うと、以下のとおりみごとに元の波形に戻る。

```py
t1=np.linspace(0, 100, 1024, endpoint=False)
sig1=ifft(freq)
plt.plot(t1, sig1)
plt.axis([0, 100, -2, 2])
plt.show()
```
![Figure_iFFT.png](https://qiita-image-store.s3.amazonaws.com/0/233744/6d6b9293-7e68-4d45-ff32-098d55cd390f.png)
ここで注意したいのは、最後のしっぽが完全には戻らないことである。

以上のとおり、FFTにおける不確定性原理は、時間軸から変換の共役変数である周波数軸に完全に移り、変換の前後で以前の空間の情報は完全に失われることである。
### ・STFT変換・逆変換してみる；窓関数について
STFTでは、時間的に変換する範囲を窓関数を乗ずることにより小時間単位にFFTを実施することにより、周波数分布（スペクトル）の時間的な変化の観察を実現している。
【参考】
・[短時間フーリエ変換@Wikipedia](https://ja.wikipedia.org/wiki/%E7%9F%AD%E6%99%82%E9%96%93%E3%83%95%E3%83%BC%E3%83%AA%E3%82%A8%E5%A4%89%E6%8F%9B)
参考によれば、窓関数の時間的な幅を変化することにより、不確定性原理が見えるということなので、これを見たいと思う。
コードは以下の通りである。

```py
#scipy.signal.istft example
#https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.istft.html
#
import numpy as np  #added by author
from scipy import signal
import matplotlib.pyplot as plt

#Generate a test signal, a 2 Vrms sine wave at 50Hz corrupted by 0.001 V**2/Hz of white noise sampled at 1024 Hz.
#テスト信号、1024 Hzでサンプリングされた0.001 V ** 2 / Hzのホワイトノイズで破損した50 Hzの2 Vrmsの正弦波を生成します

fs = 1024
N = 10*fs
```
以下のnperseq変数の値を変更すると、窓関数の時間幅を変更することができる。

```py
nperseg = 64 #2048 #1024 #128 #256 #512
```
入力波形の関数をFFTのときと同一にする。
一応、ノイズは当初のものを利用し、ノイズ除去ができるところも見る。

```py
amp = 2 * np.sqrt(2)
noise_power = 0.0001 * fs / 2
time = np.arange(N) / float(fs)
#carrier = amp * np.sin(2*np.pi*50*time)
#t = np.linspace(0, 100, 1000, endpoint=False)
carrier=[]
for t1 in time:
    if t1<1:
        sig1 = amp*np.cos(2 * np.pi * 5 * t1)  #+np.cos(2 * np.pi * 8 * t)  + np.cos(2 * np.pi * 15 * t)    #*np.exp(-0.1*t) *5
        print("5",t1)
    elif t1<2:
        sig1 = amp*np.cos(2 * np.pi * 10 * t1)
        print("10",t1)
    elif t1<4:
        sig1 = amp*np.cos(2 * np.pi * 20 * t1)
        print("20",t1)
    elif t1<6:
        sig1 = amp*np.cos(2 * np.pi * 50 * t1)
        print("30",t1)
    else:
        sig1 = amp*np.cos(2 * np.pi * 100 * t1)
        print(t1)
    carrier.append(sig1)
noise = np.random.normal(scale=np.sqrt(noise_power),
                         size=time.shape)
x = carrier + noise
```
![Figure_inputSTFT.png](https://qiita-image-store.s3.amazonaws.com/0/233744/98db2492-ebbf-f765-aae4-5898d23f45f3.png)
そして、上で定義したnpersegを使ってSTFTする。

```py
#Compute and plot the STFT’s magnitude.
#STFTの振幅を計算してプロットします
f, t, Zxx = signal.stft(x, fs=fs, nperseg=nperseg)
plt.figure()
plt.pcolormesh(t, f, np.abs(Zxx), vmin=0, vmax=amp)
plt.ylim([f[1], f[-1]])
plt.title('STFT Magnitude')
plt.ylabel('Frequency [Hz]')
plt.xlabel('Time [sec]')
plt.yscale('log')
plt.show()
```
npersegの値を変化させたときの周波数の時間依存性は以下のとおりとなる。
まさしく、Wikipediaに記載されている通りの事象が発生する。
これが、STFTにおける不確定性原理と呼ばれる現象である。
すなわち、窓の時間的な広がりが大きければ求められる周波数の広がりは狭まり、逆に時間的な遷移領域（重なり領域）が大きくなる現象である。
※理論的な話は別途あとで扱うこととし、ここでは言及しない
２０４８
![Figure_2048Hz.png](https://qiita-image-store.s3.amazonaws.com/0/233744/c78c3b84-2a68-afd8-8008-6aca4a9cfbc3.png)
１０２４
![Figure_1024Hz.png](https://qiita-image-store.s3.amazonaws.com/0/233744/c85b19b5-ffcb-ee4c-f34c-8c355a919e79.png)
５１２
![Figure_512Hz.png](https://qiita-image-store.s3.amazonaws.com/0/233744/59ba85f1-5952-4dcd-3a9a-14b3c3507999.png)
２５６
![Figure_256Hz.png](https://qiita-image-store.s3.amazonaws.com/0/233744/63dd1ddb-7bbf-45fc-a5fa-afe9fe93e9a2.png)
１２８
![Figure_128Hz.png](https://qiita-image-store.s3.amazonaws.com/0/233744/4309f9cf-cf88-19c3-8ae5-5c053eeed85c.png)
６４
![Figure_64Hz.png](https://qiita-image-store.s3.amazonaws.com/0/233744/2acd8426-ebc6-189b-ad5b-334179f056cf.png)

そして、逆変換することにより、元に戻る様子を以下で見る。
実は、これは窓関数に依存せず、すべてのケースで元波形（ノイズが除去されたもの）が得られた。ただし、境界領域や立ち上がりなどは異なることが分かる。

```py
#Zero the components that are 10% or less of the carrier magnitude, then convert back to a time series via inverse STFT
#キャリア振幅の10％以下の成分をゼロにしてから、逆STFTを介して時系列に変換し直す
Zxx = np.where(np.abs(Zxx) >= amp/10, Zxx, 0)
_, xrec = signal.istft(Zxx, fs)
#Compare the cleaned signal with the original and true carrier signals.
#きれいにされた信号を元のそして本当の搬送波信号と比較
plt.figure()
plt.plot(time, x, time, xrec, time, carrier)
plt.xlim([5, 6])
plt.xlabel('Time [sec]')
plt.ylabel('Signal')
plt.legend(['Carrier + Noise', 'Filtered via STFT', 'True Carrier'])
plt.show()
```
2048
![Figure_2048Hzamp.png](https://qiita-image-store.s3.amazonaws.com/0/233744/6484d511-3a52-ed8c-b5d8-7e68aa9e74e8.png)
1024
![Figure_1024Hzamp.png](https://qiita-image-store.s3.amazonaws.com/0/233744/04565fd3-8bc1-cd1d-4e2d-f3093efc0b8c.png)
512
![Figure_512Hzamp.png](https://qiita-image-store.s3.amazonaws.com/0/233744/8684c510-6009-fc09-1b82-d8fd15d1836f.png)
256
![Figure_256Hzamp.png](https://qiita-image-store.s3.amazonaws.com/0/233744/f8889178-be51-3a00-ea91-8a47fea0aad2.png)
128
![Figure_128Hzamp.png](https://qiita-image-store.s3.amazonaws.com/0/233744/2c96200a-5f4c-430b-36df-bc206d39c5f9.png)
64
![Figure_64Hz-amp.png](https://qiita-image-store.s3.amazonaws.com/0/233744/cecfc453-6247-39c5-9d9d-a2a07a47143f.png)


```py
#Note that the cleaned signal does not start as abruptly as the original, since some of the coefficients of the transient were also removed:
#トランジェントの係数の一部も削除されているため、クリーン化された信号は元の信号ほど急激には開始されません。
plt.figure()
plt.plot(time, x, time, xrec, time, carrier)
plt.xlim([0, 1])
plt.xlabel('Time [sec]')
plt.ylabel('Signal')
plt.legend(['Carrier + Noise', 'Filtered via STFT', 'True Carrier'])
plt.show()
```
2048；立ち上がりが大きくずれている
![Figure_2048Hzamp-2.png](https://qiita-image-store.s3.amazonaws.com/0/233744/840cd58b-eb0e-a438-c185-e1bb04f51199.png)
1024
![Figure_1024Hzamp2.png](https://qiita-image-store.s3.amazonaws.com/0/233744/c7c48c19-ce7c-9bd1-5b02-502988726aad.png)
512
![Figure_512Hzamp2.png](https://qiita-image-store.s3.amazonaws.com/0/233744/e93c9a95-491f-04c4-0928-b7c5d1961e81.png)
256
![Figure_256Hzamp2.png](https://qiita-image-store.s3.amazonaws.com/0/233744/93d50d24-c717-68ea-0108-1b4e650ce985.png)
128；ほんの少しずれが発生している
![Figure_128Hzamp2.png](https://qiita-image-store.s3.amazonaws.com/0/233744/fdc0f879-e252-327c-1a0d-b11b5e90f33e.png)
64；実は立ち上がりも綺麗に始まっているのがわかる
![Figure_64Hzamp2.png](https://qiita-image-store.s3.amazonaws.com/0/233744/a5976d46-144e-7e06-7116-a05c75b40c4f.png)
### ・wavelet変換・逆変換してみる；スペクトログラムの解釈と不確定原理
Waveletは若干手間取った。というか、参考でも記述されているが、Scipy.signal.cwtはどうもパラメータ変更ができないので、仕方なく参考の例からswan.cwtを利用することとした。
【参考】
・[Pythonで連続ウェーブレット変換(scipy, mlpy, swan)](https://qiita.com/yukiB/items/59f8484e72bb0471ad47)
まず、普通の関数で綺麗に周波数に分離できることを見る。

```py
from swan import pycwt
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 20, 0.01)
y = np.sin(2 * np.pi * 2 * x) * 2 + np.sin(2 * np.pi * 5 * x) * 2  + np.sin(2 * np.pi * 10 * x)   
plt.plot(x, y)
plt.show()
```
入力波形は以下のとおり
![Figure_1swanInput.png](https://qiita-image-store.s3.amazonaws.com/0/233744/010a8dee-4d60-2656-97a0-ba7db7a9d672.png)


```py
Fs = 1/0.01
omega0 = 8
# (1)　Freqを指定してcwt
freqs=np.arange(0.1,20,0.025)
r=pycwt.cwt_f(y,freqs,Fs,pycwt.Morlet(omega0))
rr=np.abs(r)
plt.rcParams['figure.figsize'] = (10, 6)
fig = plt.figure()
ax1 = fig.add_axes([0.1, 0.75, 0.7, 0.2])
ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.60], sharex=ax1)
ax3 = fig.add_axes([0.83, 0.1, 0.03, 0.6])
ax1.plot(x, y, 'k')
img = ax2.imshow(np.flipud(rr), extent=[0, 20,0.1, 20], aspect='auto')  #, interpolation='nearest')
twin_ax = ax2
twin_ax.set_yscale('log')
twin_ax.set_xlim(0, 20)
twin_ax.set_ylim(0.1, 20)
ax2.tick_params(which='both', labelleft=False, left=False)
twin_ax.tick_params(which='both', labelleft=True, left=True, labelright=False)
fig.colorbar(img, cax=ax3)
plt.show()
```
周波数のところにバンドが出現しているのがわかる。
![Figure_swanFvst.png](https://qiita-image-store.s3.amazonaws.com/0/233744/18f735df-81f9-424b-2703-8355d599a2a8.png)

```py
plt.plot(freqs,rr)
plt.xscale('log')
plt.show()
```
そして、パワースペクトルの絵は以下のとおり
![Figure_PvsF.png](https://qiita-image-store.s3.amazonaws.com/0/233744/295ca7a2-323b-ae34-987f-09ff9e9b0286.png)

ということで、不確定性原理が出現するかどうを見る。
コードは以下の通り

```py
from swan import pycwt
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0, 20, 0.01)
#y = np.sin(2 * np.pi * 2 * x) * 2 + np.sin(2 * np.pi * 5 * x) * 2  + np.sin(2 * np.pi * 10 * x)   
amp=1
y=[]
for t1 in x:
    if t1<3:
        sig1 = amp*np.cos(2 * np.pi * 0.5 * t1)  #+np.cos(2 * np.pi * 8 * t)  + np.cos(2 * np.pi * 15 * t)    #*np.exp(-0.1*t) *5
    elif t1<8:
        sig1 = amp*np.cos(2 * np.pi * 4 * t1)
    elif t1<12:
        sig1 = amp*np.cos(2 * np.pi * 7 * t1)
    elif t1<15:
        sig1 = amp*np.cos(2 * np.pi * 12 * t1)
    else:
        sig1 = amp*np.cos(2 * np.pi * 15 * t1)
    y.append(sig1)
plt.plot(x, y)
plt.show()

Fs = 1/0.01
omega0 = 0.2 #1 #2 #8
# (1)　Freqを指定してcwt
freqs=np.arange(0.1,20,0.025)
r=pycwt.cwt_f(y,freqs,Fs,pycwt.Morlet(omega0))
rr=np.abs(r)

plt.rcParams['figure.figsize'] = (10, 6)
fig = plt.figure()
ax1 = fig.add_axes([0.1, 0.75, 0.7, 0.2])
ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.60], sharex=ax1)
ax3 = fig.add_axes([0.83, 0.1, 0.03, 0.6])

ax1.plot(x, y, 'k')

img = ax2.imshow(np.flipud(rr), extent=[0, 20,0.1, 20], aspect='auto')  #, interpolation='nearest')
twin_ax = ax2
twin_ax.set_yscale('log')
twin_ax.set_xlim(0, 20)
twin_ax.set_ylim(0.1, 20)
ax2.tick_params(which='both', labelleft=False, left=False)
twin_ax.tick_params(which='both', labelleft=True, left=True, labelright=False)
fig.colorbar(img, cax=ax3)
plt.show()
```
一目見てわかるように、不確定性原理の現象が起こっている。
omega0=8；時間軸がぼけぼけで境界が曖昧、特に低周波が酷い
![Figure_swan_hukakutei1.png](https://qiita-image-store.s3.amazonaws.com/0/233744/45099300-4e93-aa30-417d-2752dfbaa683.png)
時間軸の曖昧さは明らかに小さくなっている。
omega0=2；時間軸のぼけが収まってきた、特に低周波の時間領域がまとまりだした
![Figure_swan_omega2.png](https://qiita-image-store.s3.amazonaws.com/0/233744/b8c56686-8990-1f27-662c-2f65875615b8.png)
omega0=1；時間軸のぼけがかなり収まったが、周波数のバンド化が酷くなった
![Figure_swan_omega1.png](https://qiita-image-store.s3.amazonaws.com/0/233744/d58bdce6-0434-7525-6a8f-7c01cea1c94b.png)
omega0=0.5；周波数のバンド化がさらに酷くなった、
![Figure_swan_omega05.png](https://qiita-image-store.s3.amazonaws.com/0/233744/4099b605-fb2a-07fc-92c7-0ddbda9df8d4.png)
omega0=0.2；周波数のバンドがさらに広がりピークが見えなくなった、時間軸の周波数の移り変わりははっきりしている。
![Figure_swan_omega02.png](https://qiita-image-store.s3.amazonaws.com/0/233744/2d104717-c076-d185-6d9a-6632ebe0bbae.png)


```py
plt.plot(freqs,rr)
plt.xscale('log')
plt.show()
```
また、小さい周波数で多くの窓関数によるものと思われるゴーストも出現している。
omega0=8；周波数のピークは、一応分離している
![Figure_swan_hukakutei2.png](https://qiita-image-store.s3.amazonaws.com/0/233744/87e5292c-0d78-35f8-6007-1ffee42dd993.png)
そして以下では、周波数の重なりが大きくなり、より不確定になっている。
omega0=2；高周波領域でオーバーラップが始まった
![Figure_swan_omega2_pvsf.png](https://qiita-image-store.s3.amazonaws.com/0/233744/e8d00b39-1cb9-1f3a-4b0e-95ba3cfd702a.png)
omega0=1；高周波領域でオーバーラップが酷くなった
![Figure_swan_omega2_pvsf.png](https://qiita-image-store.s3.amazonaws.com/0/233744/de97d775-9e7f-14fd-c984-3b9a135b3f3f.png)
omega0=0.5；かなりオーバーラップしている
![Figure_swan_omega05_pvsf.png](https://qiita-image-store.s3.amazonaws.com/0/233744/0ba73caf-ba3f-5356-6cff-cd4341f390eb.png)
omega0=0.2;ぼけぼけ
![Figure_swan_omega02_pvsf.png](https://qiita-image-store.s3.amazonaws.com/0/233744/e55dafe7-f9c5-2bf7-1c2f-602e549840d4.png)


###まとめ
・FFT、STFT、そしてWavelet変換で起こる不確定性原理について実際に計算しつつ確認した
・FFTでは、共役関係にある時間と周波数依存性は同時には定まらないことが分かる
・STFTとWavelet変換では、どちらもスペクトログラムにおいて不確定性原理が働く現象が現れることが分かった

・次回は、一次元の実時系列データに応用したいと思う
・窓関数は一種の観測窓であり、これはいわゆる観測の理論である
・次々回あたりに、理論的な定式化による裏付けと観測の理論をまとめる予定です
###おまけ
実は前回のWavelet変換のScipyサイトの例題の図がもう一つ理解できていなかった。
そこで、今回はSwanのWavelet変換の入力を前回と同じにしてやってみた。

```py
from swan import pycwt
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(-1, 1, 0.01)
y  = np.cos(2 * np.pi * 7 * x) + np.real(np.exp(-7*(x-0.4)**2)*np.exp(1j*2*np.pi*2*(x-0.4)))   #change input function

plt.plot(x, y)
plt.show()
```
![Figure_swan_exFunction.png](https://qiita-image-store.s3.amazonaws.com/0/233744/95b4783f-54ac-b5c6-1344-fc988240287f.png)


```py
Fs = 1/0.01
omega0 = 1
# (1)　Freqを指定してcwt
freqs=np.arange(0.1,20,0.025)
r=pycwt.cwt_f(y,freqs,Fs,pycwt.Morlet(omega0))
Z = (r.real, r.imag) #added
rr=np.abs(r)   #added

plt.rcParams['figure.figsize'] = (10, 6)
fig = plt.figure()
ax1 = fig.add_axes([0.1, 0.75, 0.7, 0.2])
ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.60], sharex=ax1)
ax3 = fig.add_axes([0.83, 0.1, 0.03, 0.6])

ax1.plot(x, y, 'k')

img = ax2.imshow(np.flipud(rr), extent=[-1, 1,0.1, 20], aspect='auto')  #, interpolation='nearest')
twin_ax = ax2
twin_ax.set_yscale('log')
twin_ax.set_xlim(-1, 1)
twin_ax.set_ylim(0.1, 20)
ax2.tick_params(which='both', labelleft=False, left=False)
twin_ax.tick_params(which='both', labelleft=True, left=True, labelright=False)
fig.colorbar(img, cax=ax3)
plt.show()
```
![Figure_swan_exwavelet_fvst.png](https://qiita-image-store.s3.amazonaws.com/0/233744/2d88a4ef-8bc5-b056-e2fc-7ab88d0ecd19.png)
以下を追加して、Scipyのcwtの例題が何を記載しているか確認した。

```py
#added below 
fig2=plt.figure()
ax = fig2.add_subplot(111)
img2=ax.imshow(np.flipud(r.real), extent=[-1, 1,0.1, 20], aspect='auto')  #, interpolation='nearest')
ax.set_yscale('log')
fig2.colorbar(img2)
plt.show()
```
以下の通り、振幅（real part of imagenary）を周波数vs時間で記載していることが分かる。
※一応、これですっきりした
　⇒ただしScipy使うには、もうちょっとゆっくり考える必要がありそう
![Figure_swan_exwavelet_realpart.png](https://qiita-image-store.s3.amazonaws.com/0/233744/46044807-89a8-212d-c461-b7b89b4dd31d.png)

```py
plt.plot(freqs,rr)
plt.xscale('log')
plt.show()
```
![Figure_swan_ex_powervsfreq.png](https://qiita-image-store.s3.amazonaws.com/0/233744/646465aa-c607-00d9-4623-582aaef48fb1.png)