Differenza tra convoluzione di Tensorflow e convoluzione numpy: python, numpy, tensorflow, convoluzione

import numpy as np
import tensorflow as tf

X_node    = tf.placeholder("float",[1,10,1])
filter_tf = tf.Variable( tf.truncated_normal([3,1,1],stddev=0.1) )

Xconv_tf_tensor = tf.nn.conv1d(X_node, filter_tf,1,"SAME")

X = np.random.normal(0,1,[1,10,1])
with tf.Session() as sess:
tf.global_variables_initializer().run()
feed_dict = {X_node: X}
filter_np = filter_tf.eval()
Xconv_tf = sess.run(Xconv_tf_tensor,feed_dict)
Xconv_np = np.convolve(X[0,:,0],filter_np[:,0,0],"SAME")

Sto cercando di vedere i risultati delle circonvoluzionida Tensorflow per verificare se si comporta come volevo. Quando eseguo la convoluzione numerica e la confronta con la convoluzione di Tensorflow, la risposta è diversa. Il codice sopra è come ho eseguito il test. Speravo il Xconv_tf e Xconv_np sarebbe uguale.

Il mio obiettivo finale è la convoluzione in 2D su amatrice con un filtro 1 dimensionale che esegue 1d-convoluzione su ogni riga con lo stesso filtro. Per fare in modo che questo lavoro (che sarà fondamentalmente un ciclo di convoluzione 1d sulle righe) ho bisogno di capire perché il mio np.convolve e tf.conv1d dammi risposte diverse

risposte:

Il problema che vedi è che TF non calcola realmente la convoluzione. Se darai un'occhiata alla spiegazione di cosa la convoluzione effettivamente lo fa (controlla Spiegazioni visive della convoluzione), vedrai che la seconda funzione è capovolta:

1. Esprimere ogni funzione in termini di variabile fittizia
2. Rifletti una delle funzioni (questo è il lancio)
3. ..... Alcune altre cose che non copierò qui.

La TF fa tutto tranne quella vibrazione. Quindi tutto ciò che devi fare è capovolgere il kernel in TF o in numpy. Flipping per 1d case è solo kernel in ordine inverso, per 2d dovrai capovolgere entrambi gli assi (ruotare il kernel 2 volte).

import tensorflow as tf
import numpy as np

I = [1, 0, 2, 3, 0, 1, 1]
K = [2, 1, 3]

i = tf.constant(I, dtype=tf.float32, name="i")
k = tf.constant(K, dtype=tf.float32, name="k")

data   = tf.reshape(i, [1, int(i.shape[0]), 1], name="data")
kernel = tf.reshape(k, [int(k.shape[0]), 1, 1], name="kernel")

res = tf.squeeze(tf.nn.conv1d(data, kernel, 1, "VALID"))
with tf.Session() as sess:
print sess.run(res)
print np.convolve(I, K[::-1], "VALID")

L'ordine del filtro è invertito. La convoluzione di TensorFlow è in realtà una correlazione. Numpy riceve la notazione dalla matematica, TF riceve la notazione dai documenti di apprendimento automatico e da qualche parte l'ordine viene invertito.

Questo stampa True

filter_np2=filter_np[::-1,0,0]
np.allclose(np.convolve(X[0,:,0],filter_np2,"SAME"),  Xconv_tf.flatten())    np.convolve(X[0,:,0],filter_np2,"SAME")