Come funziona tensorflow batch_matmul?

Question

Tensorflow ha una funzione chiamata batch_matmul che moltiplica i tensori dimensionali superiori. Ma ho difficoltà a capire come funziona, forse in parte perché ho difficoltà a visualizzarlo.

Quello che voglio fare è moltiplicare una matrice per ogni fetta di un tensore 3D, ma io non capisco quale sia la forma di un tensore è. Z è la dimensione più interna? Quale dei seguenti è corretto?

vorrei la maggior parte preferisce il primo a essere corretto - è più intuitivo per me e facile da vedere nell'output .eval(). Ma sospetto che il secondo sia corretto.

tensorflow dice che batch_matmul esegue:

out[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :]) 

Che cosa vuol dire? Cosa significa nel contesto del mio esempio? Cosa si moltiplica con cosa? E perché non ottengo un tensore 3D come mi aspettavo?

Answer 1

Potete immaginarlo come un matmul su ogni esempio di addestramento nel batch.

Ad esempio, se si hanno due tensori con le seguenti dimensioni:

a.shape = [100,2,5] 
b.shape = [100,5,2] 

e si fa un batch.matmul (a, b), l'output avrà la forma [100,2,2] .

100 è la dimensione del batch, le altre due dimensioni sono le dimensioni dei dati.

Answer 2

È semplicemente come scomporre sulla prima dimensione rispettivamente, moltiplicare e concatenarli. Se si desidera eseguire il 3D in 2D, è possibile ridisegnarlo, moltiplicarlo e ridisegnarlo. Cioè [100, 2, 5] -> [200, 5] -> [200, 2] -> [100, 2, 2]

Answer 3

Ora è possibile farlo utilizzando tf.einsum, a partire da Tensorflow 0,11. 0rc0.

Ad esempio,

M1 = tf.Variable(tf.random_normal([2,3,4])) 
M2 = tf.Variable(tf.random_normal([5,4])) 
N = tf.einsum('ijk,lk->ijl',M1,M2)  

moltiplica la matrice M2 con ogni frame (3 fotogrammi) in ogni gruppo (2 lotti) in M1.

Il risultato è:

[array([[[ 0.80474716, -1.38590837, -0.3379252 , -1.24965811], 
     [ 2.57852983, 0.05492432, 0.23039417, -0.74263287], 
     [-2.42627382, 1.70774114, 1.19503212, 0.43006262]], 

     [[-1.04652011, -0.32753903, -1.26430523, 0.8810069 ], 
     [-0.48935518, 0.12831448, -1.30816901, -0.01271309], 
     [ 2.33260512, -1.22395933, -0.92082584, 0.48991606]]], dtype=float32), 
array([[ 1.71076882, 0.79229093, -0.58058828, -0.23246667], 
     [ 0.20446332, 1.30742455, -0.07969904, 0.9247328 ], 
     [-0.32047141, 0.66072595, -1.12330854, 0.80426538], 
     [-0.02781649, -0.29672042, 2.17819595, -0.73862702], 
     [-0.99663496, 1.3840003 , -1.39621222, 0.77119476]], dtype=float32), 
array([[[ 0.76539308, 2.77609682, -1.79906654, 0.57580602, -3.21205115], 
     [ 4.49365759, -0.10607499, -1.64613271, 0.96234947, -3.38823152], 
     [-3.59156275, 2.03910899, 0.90939498, 1.84612727, 3.44476724]], 

     [[-1.52062428, 0.27325237, 2.24773455, -3.27834225, 3.03435063], 
     [ 0.02695178, 0.16020992, 1.70085776, -2.8645196 , 2.48197317], 
     [ 3.44154787, -0.59687197, -0.12784094, -2.06931567, -2.35522676]]], dtype=float32)] 

ho verificato, l'aritmetica è corretto.

Answer 4

La risposta a questa risposta specifica sta utilizzando la funzione tf.scan.

Se a = [5,3,2] #dimension 5 lotti, con la stuoia 3X2 in ciascun lotto
e b = [2,3] # una matrice costante da moltiplicare con ciascun campione

quindi lasciare def fn (a, x): return tf.matmul (x, b)

initializer = tf.Variable (tf.random_number (3,3))

h = tf.scan (fn, uscite, inizializzatore)

questo h memorizza tutte le uscite.

Answer 5

Prima di tutto tf.batch_matmul() era removed e non più disponibile. Ora si supponga di utilizzare tf.matmul():

Gli ingressi devono essere matrici (o tensori di rango> 2, che rappresentano lotti di matrici), con dimensioni interne corrispondenti, eventualmente dopo trasposizione.

Quindi cerchiamo di assumere di avere il seguente codice:

import tensorflow as tf 
batch_size, n, m, k = 10, 3, 5, 2 
A = tf.Variable(tf.random_normal(shape=(batch_size, n, m))) 
B = tf.Variable(tf.random_normal(shape=(batch_size, m, k))) 
tf.matmul(A, B) 

Ora si riceverà un tensore della forma (batch_size, n, k). Ecco cosa sta succedendo qui. Si supponga di avere batch_size di matrici nxm e batch_size di matrici mxk. Ora per ogni coppia di essi viene calcolato nxm X mxk che fornisce una matrice nxk. Avrai batch_size di loro.

noti che qualcosa di simile è valido anche:

A = tf.Variable(tf.random_normal(shape=(a, b, n, m))) 
B = tf.Variable(tf.random_normal(shape=(a, b, m, k))) 
tf.matmul(A, B) 

e vi darà una forma (a, b, n, k)