¿Cómo hacer lotes de productos internos en Tensorflow?

Tengo dos tensor a:[batch_size, dim] b:[batch_size, dim]. Quiero hacer un producto interno para cada par en el lote, generando c:[batch_size, 1], dónde c[i,0]=a[i,:].T*b[i,:]. ¿Cómo?

No hay un .dot_productmétodo nativo . Sin embargo, un producto de punto entre dos vectores solo se suma por elementos, por lo que funciona el siguiente ejemplo:

import tensorflow as tf

# Arbitrarity, we'll use placeholders and allow batch size to vary,
# but fix vector dimensions.
# You can change this as you see fit
a = tf.placeholder(tf.float32, shape=(None, 3))
b = tf.placeholder(tf.float32, shape=(None, 3))

c = tf.reduce_sum( tf.multiply( a, b ), 1, keep_dims=True )

with tf.Session() as session:
    print( c.eval(
        feed_dict={ a: [[1,2,3],[4,5,6]], b: [[2,3,4],[5,6,7]] }
    ) )

El resultado es:

[[ 20.]
 [ 92.]]

Otra opción que vale la pena ver es [tf.einsum][1]: es esencialmente una versión simplificada de la notación de Einstein .

Siguiendo junto con los ejemplos de Neil y dumkar:

import tensorflow as tf

a = tf.placeholder(tf.float32, shape=(None, 3))
b = tf.placeholder(tf.float32, shape=(None, 3))

c = tf.einsum('ij,ij->i', a, b)

with tf.Session() as session:
    print( c.eval(
        feed_dict={ a: [[1,2,3],[4,5,6]], b: [[2,3,4],[5,6,7]] }
    ) )

El primer argumento einsumes una ecuación que representa los ejes que se multiplicarán y se sumarán. Las reglas básicas para una ecuación son:

1. Los tensores de entrada se describen mediante una cadena separada por comas de etiquetas de dimensión
2. Las etiquetas repetidas indican que las dimensiones correspondientes se multiplicarán
3. El tensor de salida se describe mediante otra cadena de etiquetas de dimensión que representan las entradas (o productos) correspondientes.
4. Las etiquetas que faltan en la cadena de salida se suman

En nuestro caso, ij,ij->isignifica que nuestras entradas serán 2 matrices de igual forma (i,j), y nuestra salida será un vector de forma (i,).

Una vez que lo domines, encontrarás que einsum generaliza una gran cantidad de otras operaciones:

X = [[1, 2]]
Y = [[3, 4], [5, 6]]

einsum('ab->ba', X) == [[1],[2]]   # transpose
einsum('ab->a',  X) ==  [3]        # sum over last dimension
einsum('ab->',   X) ==   3         # sum over both dimensions

einsum('ab,bc->ac',  X, Y) == [[13,16]]          # matrix multiply
einsum('ab,bc->abc', X, Y) == [[[3,4],[10,12]]]  # multiply and broadcast

Desafortunadamente, einsumtiene un impacto de rendimiento bastante considerable en comparación con una multiplicación manual + reducción. Cuando el rendimiento es crítico, definitivamente recomendaría seguir con la solución de Neil.

Tomar la diagonal de tf.tensordot también hace lo que quieres, si configuras el eje para, por ejemplo,

[[1], [1]]

He adaptado el ejemplo de Neil Slater:

import tensorflow as tf

# Arbitrarity, we'll use placeholders and allow batch size to vary,
# but fix vector dimensions.
# You can change this as you see fit
a = tf.placeholder(tf.float32, shape=(None, 3))
b = tf.placeholder(tf.float32, shape=(None, 3))

c = tf.diag_part(tf.tensordot( a, b, axes=[[1],[1]]))

with tf.Session() as session:
    print( c.eval(
        feed_dict={ a: [[1,2,3],[4,5,6]], b: [[2,3,4],[5,6,7]] }
    ) )

que ahora también da:

[ 20.  92.]

Sin embargo, esto podría ser subóptimo para matrices grandes (ver discusión aquí )