你還弄不懂的傅立葉變換，神經網路只用了30多行程式碼就學會了

明敏 發自 凹非寺 量子位 報道 | 公眾號 QbitAI

在我們的生活中，大到天體觀測、小到MP3播放器上的頻譜，沒有傅立葉變換都無法實現。

通俗來講，離散傅立葉變換（DFT）就是把一串複雜波形中分成不同頻率成分。

比如聲音，如果用聲波記錄儀顯示聲音的話，其實生活中絕大部分聲音都是非常複雜、甚至雜亂無章的。

而通過傅立葉變換，就能把這些雜亂的聲波轉化為正弦波，也就是我們平常看到的音樂頻譜圖的樣子。

不過在實際計算中，這個過程其實非常複雜。

如果把聲波視作一個連續函數，它可以唯一表示為一堆三角函數相疊加。不過在疊加過程中，每個三角函數的加權係數不同，有的要加高一些、有的要壓低一些，有的甚至不加。

傅立葉變換要找到這些三角函數以及它們各自的權重。

這不就巧了，這種找啊找的過程，像極了神經網路。

神經網路的本質其實就是逼近一個函數。

那豈不是可以用訓練神經網路的方式來搞定傅立葉變換？

這還真的可行，並且最近有人在網上釋出了自己訓練的過程和結果。

DFT=神經網路

該怎麼訓練神經網路呢？這位網友給出的思路是這樣的：

首先要把離散傅立葉變換（DFT）看作是一個人工神經網路，這是一個單層網路，沒有bias、沒有啟用函數，並且對於權重有特定的值。它輸出節點的數量等於傅立葉變換計算後頻率的數量。

具體方法如下：

這是一個DFT：

k表示每N個樣本的迴圈次數；N表示訊號的長度；表示訊號在樣本n處的值。一個訊號可以表示為所有正弦訊號的和。

yk是一個復值，它給出了訊號x中頻率為k的正弦訊號的資訊；從yk我們可以計算正弦的振幅和相位。

換成矩陣式，它就變成了這樣：

這裡給出了特定值k的傅立葉值。

不過通常情況下，我們要計算全頻譜，即k從[0,1,…N-1]的值，這可以用一個矩陣來表示（k按列遞增，n按行遞增）：

簡化後得到：

看到這裡應該還很熟悉，因為它是一個沒有bias和啟用函數的神經網路層。

指數矩陣包含權值，可以稱之為複合傅立葉權值（Complex Fourier weights），通常情況下我們並不知道神經網路的權重，不過在這裡可以。

不用複數通常我們也不會在神經網路中使用複數，為了適應這種情況，就需要把矩陣的大小翻倍，使其左邊部分包含實數，右邊部分包含虛數。

將

帶入DFT，可以得到：

然後用實部（cos形式）來表示矩陣的左半部分，用虛部（sin形式）來表示矩陣的右半部分：

簡化後可以得到：

將

稱為傅立葉權重；

需要注意的是，y^和y實際上包含相同的資訊，但是y^

不使用複數，所以它的長度是y的兩倍。

換句話說，我們可以用

或

表示振幅和相位，但是我們通常會使用

現在，就可以將傅立葉層加到網路中了。

用傅立葉權重計算傅立葉變換

現在就可以用神經網路來實現

，並用快速傅立葉變換（FFT）檢查它是否正確。

import matplotlib.pyplot as plt

y_real = y[:, :signal_length]

y_imag = y[:, signal_length:]

tvals = np.arange(signal_length).reshape([-1, 1])

freqs = np.arange(signal_length).reshape([1, -1])

arg_vals = 2 * np.pi * tvals * freqs / signal_length

sinusoids = (y_real * np.cos(arg_vals) - y_imag * np.sin(arg_vals)) / signal_length

reconstructed_signal = np.sum(sinusoids, axis=1)

print('rmse:', np.sqrt(np.mean((x - reconstructed_signal)**2)))

plt.subplot(2, 1, 1)plt.plot(x[0,:])

plt.title('Original signal')

plt.subplot(2, 1, 2)

plt.plot(reconstructed_signal)

plt.title('Signal reconstructed from sinusoids after DFT')

plt.tight_layout()

plt.show()

rmse: 2.3243522568191728e-15

得到的這個微小誤差值可以證明，計算的結果是我們想要的。

另一種方法是重構訊號：import matplotlib.pyplot as plt

y_real = y[:, :signal_length]

y_imag = y[:, signal_length:]

tvals = np.arange(signal_length).reshape([-1, 1])

freqs = np.arange(signal_length).reshape([1, -1])

arg_vals = 2 * np.pi * tvals * freqs / signal_length

sinusoids = (y_real * np.cos(arg_vals) - y_imag * np.sin(arg_vals)) / signal_length

reconstructed_signal = np.sum(sinusoids, axis=1)

print('rmse:', np.sqrt(np.mean((x - reconstructed_signal)**2)))

plt.subplot(2, 1, 1)

plt.plot(x[0,:])

plt.title('Original signal')

plt.subplot(2, 1, 2)

plt.plot(reconstructed_signal)

plt.title('Signal reconstructed from sinusoids after DFT')

plt.tight_layout()plt.show()

rmse:2.3243522568191728e-15

最後可以看到，DFT後從正弦訊號重建的訊號和原始訊號能夠很好地重合。

通過梯度下降學習傅立葉變換

現在就到了讓神經網路真正來學習的部分，這一步就不需要向之前那樣預先計算權重值了。

首先，要用FFT來訓練神經網路學習離散傅立葉變換：

importtensorflow as tf

signal_length = 32

# Initialise weight vector to train:

W_learned = tf.Variable(np.random.random([signal_length, 2 * signal_length]) - 0.5)

# Expected weights, for comparison:

W_expected = create_fourier_weights(signal_length)

losses = []

rmses = []

fori in range(1000):

# Generate a random signal each iteration:

x = np.random.random([1, signal_length]) - 0.5

# Compute the expected result using the FFT:

fft = np.fft.fft(x)

y_true = np.hstack([fft.real, fft.imag])

withtf.GradientTape() as tape:

y_pred = tf.matmul(x, W_learned)

loss = tf.reduce_sum(tf.square(y_pred - y_true))

# Train weights, via gradient descent:

W_gradient = tape.gradient(loss, W_learned)

W_learned = tf.Variable(W_learned - 0.1 * W_gradient)

losses.append(loss)

rmses.append(np.sqrt(np.mean((W_learned- W_expected)**2)))

Final loss value 1.6738563548424711e-09

Final weights' rmse value 3.1525832404710523e-06

得出結果如上，這證實了神經網路確實能夠學習離散傅立葉變換。

訓練網路學習DFT

除了用快速傅立葉變化的方法，還可以通過網路來重建輸入訊號來學習DFT。(類似於autoencoders自編碼器)。

自編碼器（autoencoder, AE）是一類在半監督學習和非監督學習中使用的人工神經網路（Artificial Neural Networks, ANNs），其功能是通過將輸入資訊作為學習目標，對輸入資訊進行表徵學習（representation learning）。

W_learned = tf.Variable(np.random.random([signal_length, 2 * signal_length]) - 0.5)

tvals = np.arange(signal_length).reshape([-1, 1])

freqs = np.arange(signal_length).reshape([1, -1])

arg_vals = 2 * np.pi * tvals * freqs / signal_lengthcos_vals = tf.

cos(arg_vals) / signal_lengthsin_vals = tf.

sin(arg_vals) / signal_lengthlosses = []

rmses = []

fori in range(10000):

x = np.random.random([1, signal_length]) - 0.5

withtf.GradientTape() as tape:

y_pred = tf.matmul(x, W_learned)

y_real = y_pred[:, 0:signal_length]

y_imag = y_pred[:, signal_length:]

sinusoids = y_real * cos_vals - y_imag * sin_vals

reconstructed_signal = tf.reduce_sum(sinusoids, axis=1)

loss = tf.reduce_sum(tf.square(x - reconstructed_signal))

W_gradient = tape.gradient(loss, W_learned)

W_learned = tf.Variable(W_learned - 0.5 * W_gradient)

losses.append(loss)

rmses.append(np.sqrt(np.mean((W_learned- W_expected)**2))

Final loss value 4.161919455121241e-22

Final weights' rmse value 0.20243339269590094

作者用這一模型進行了很多測試，最後得到的權重不像上面的例子中那樣接近傅立葉權值，但是可以看到重建的訊號是一致的。

換成輸入振幅和相位試試看呢。

W_learned = tf.Variable(np.random.random([signal_length, 2 * signal_length]) - 0.5)

losses = []

rmses = []

fori in range(10000):

x = np.random.random([1, signal_length]) - .5

withtf.GradientTape() as tape:

y_pred = tf.matmul(x, W_learned)

y_real = y_pred[:, 0:signal_length]

y_imag = y_pred[:, signal_length:]

amplitudes = tf.sqrt(y_real**2 + y_imag**2) / signal_length

phases = tf.atan2(y_imag, y_real)

sinusoids = amplitudes * tf.cos(arg_vals + phases)

reconstructed_signal = tf.reduce_sum(sinusoids, axis=1)

loss = tf.reduce_sum(tf.square(x - reconstructed_signal))

W_gradient = tape.gradient(loss, W_learned)

W_learned = tf.Variable(W_learned - 0.5 * W_gradient)

losses.append(loss)

rmses.append(np.sqrt(np.mean((W_learned- W_expected)**2)))

Final loss value 2.2379359316633115e-21Final weights' rmse value 0.2080118219691059

可以看到，重建訊號再次一致；

不過，和此前一樣，輸入振幅和相位最終得到的權值也不完全等同於傅立葉權值(但非常接近)。

由此可以得出結論，雖然最後得到的權重還不是最準確的，但是也能夠獲得局部的最優解。

這樣一來，神經網路就學會了傅立葉變換！

值得一提的是，這個方法目前還有疑問存在：首先，它並解釋計算出的權值和真正的傅立葉權值相差多少；

而且，也並沒有說明將傅立葉層放到模型中能帶來哪些益處。

原文連結：https://sidsite.com/posts/fourier-nets/