Question

这与TensorFlow中的实现问题有关。我有一个H大小的张量(batch_size, time_steps, 256)（但是在构建期间，batch_size和time_steps是None）。

我想计算形状为A的张量(batch_size, time_steps, time_steps, n_dim)，它是整个时间维度上的笛卡尔积。因此，简单来说：

A[:,i,j,:] = some_func(H[:,i,:], H[:,j,:])

由于在构建图形时time_steps的数量为None，那么计算A的一种优雅方法是什么？

Answer 1

您可以使用TensorFlow的广播属性在一个张量之间构造笛卡尔乘积，方法是将一个张量扩展到另一个维度，然后再乘以另一个张量。

import tensorflow as tf

A = tf.placeholder(shape=(None, None, 256), dtype=tf.float32)
B = tf.placeholder(shape=(None, None, 256), dtype=tf.float32)

A_ = tf.expand_dims(A, axis=1)

A_*B

给予

<tf.Tensor 'mul_1:0' shape=(?, ?, ?, 256) dtype=float32>

Answer 2

对于指定time_steps轴大小（即不是None）的情况，我有解决方案。我们可以轻松地使用K.repeat_elements和K.tile来形成笛卡尔积的张量：

from keras import layers, models
from keras import backend as K

def some_func(a, b):
    # define the some_func here
    return a + b

def cart_prod(x):
    shp = K.int_shape(x)[1]
    x_rep = K.repeat_elements(x, shp, axis=1)
    x_tile = K.tile(x, [1, shp, 1])
    res = some_func(x_rep, x_tile)
    return K.reshape(res, [-1, shp, shp, K.shape(res)[-1]])

inp = layers.Input((3, 2))
out = layers.Lambda(cart_prod)(inp)
model = models.Model(inp, out)

model.predict(np.arange(6).reshape(1, 3, 2))

输出：

array([[[[ 0.,  2.],
         [ 2.,  4.],
         [ 4.,  6.]],

        [[ 2.,  4.],
         [ 4.,  6.],
         [ 6.,  8.]],

        [[ 4.,  6.],
         [ 6.,  8.],
         [ 8., 10.]]]], dtype=float32)

尺寸为无时的笛卡尔积

2 个答案: