tf.multiply vs tf.matmul计算点积

Question

我有一个矩阵（矢量）X形状[3,4]，我想计算每对矢量（X [1] .X [1]）和（X [1] .X [之间的点积] 2]）...等。

我看到他们使用的余弦相似代码

tf.reduce_sum（tf.multyply（X，X），axis = 1）

计算向量矩阵中向量之间的点积。然而，这个结果只计算（X [​​i]，X [i]）之间的点积。

我使用了tf.matmul（X，X，transpose_b = True）来计算每两个向量之间的点积，但我仍然感到困惑，为什么tf.multiply没有这样做我认为我的代码存在问题。

代码是：

data=[[1.0,2.0,4.0,5.0],[0.0,6.0,7.0,8.0],[8.0,1.0,1.0,1.0]]
X=tf.constant(data)
matResult=tf.matmul(X, X, transpose_b=True)

multiplyResult=tf.reduce_sum(tf.multiply(X,X),axis=1)
with tf.Session() as sess:
   print('matResult')
   print(sess.run([matResult]))
   print()
   print('multiplyResult')
   print(sess.run([multiplyResult]))

输出是：

matResult
[array([[  46.,   80.,   19.],
       [  80.,  149.,   21.],
       [  19.,   21.,   67.]], dtype=float32)]

multiplyResult
 [array([  46.,  149.,   67.], dtype=float32)]

我很感激任何建议

Answer 1

tf.multiply(X, Y) 元素乘法

[[1 2]    [[1 3]      [[1 6]
 [3 4]] .  [2 1]]  =   [6 4]]

tf.matmul 矩阵乘法运算

[[1 0]    [[1 3]      [[1 3]
 [0 1]] .  [2 1]]  =   [2 1]]

使用tf.matmul(X, X, transpose_b=True)表示您正在计算X . X^T X . X^T其中^T表示矩阵的转置和. 是矩阵乘法。

tf.reduce_sum(_, axis=1)取第一轴的总和（从0开始计数），这意味着你要对行进行求和：

tf.reduce_sum([[a b], [c, d]], axis=1) = [a+b, c+d]

这意味着：

tf.reduce_sum(tf.multiply(X, X), axis=1) = [X[1].X[1], ..., X[n].X[n]]

如果您只想要每行的规范，那么这就是您想要的那个。 另一方面

 tf.matmul(X, X, transpose_b=True) = [[ X[1].X[1], X[1].X[2], ..., X[1].X[n]], 
                                       [X[2].X[1], ..., X[2].X[n]],
                                       ...
                                       [X[n].X[1], ..., X[n].X[n]]

如果你想要所有行对之间的相似性，那么这就是你所需要的。

Answer 2

tf.multiply(X, X)作用基本上是将矩阵的每个元素与自身相乘，就像

[[1 2]
 [3 4]]

会变成

[[1 4]
 [9 16]]

而tf.reduce_sum(_, axis=1)取每行的总和，因此上一个例子的结果将是

[5 25]

这正是（根据定义）等于[X[0, :] @ X[0, :], X[1, :] @ X[1, :]] 。

只需用变量名[[ab] [cd]]而不是实际数字来记下它，看看tf.matmul(X, X)和tf.multiply(X, X)做了什么。

Answer 3

简而言之， tf.multiply（）做元素明智的产品（点积）。 而tf.matmul（）进行实际的矩阵多重表达。 所以tf.multiply（）需要相同形状的参数，以便元素明智的产品是可能的，即形状是（n，m）和（n，m） 。 但是tf.matmul（）需要形状（n，m）和（m，p）的参数，因此得到的矩阵是（n，p）[通常的数学]。

一旦理解，这可以很容易地应用于多维矩阵。