高维度张量相乘
通过tf.reshape()对高维度张量降维，验证高维度张量相乘结果

通过tf.reshape()对高维度张量降维，验证高维度张量相乘结果
最近遇到了需要将高于2维度的张量相乘的需求，通过互联网资源查到了先用tf.reshape()降到2维再运算的骚操作。下面验证这种操作的可靠性。
#测试多维矩阵乘法。问题来自于mul-attention模型的矩阵运算
#2019-7-14编辑
import tensorflow as tf
import numpy as np

#定义两个三维矩阵
#k.shape = [batch_size, seq_length, embedded_size]
#w.shape = [embedded_size, d_k, h_num]
k = tf.Variable(tf.random_uniform([3, 4, 5]))
w = tf.Variable(tf.random_uniform([5, 6, 7]))

#实现k与w的相乘，目标维度为[batch_size, seq_length, d_k, h_num]
#通过reshape的方式，将矩阵降到2维，实现矩阵乘法，再通过reshape还原
k_2d = tf.reshape(k, [-1, 5])
w_2d = tf.reshape(w, [5, -1])
r_2d = tf.matmul(k_2d, w_2d)
r_4d = tf.reshape(r_2d, [-1, 4, 6, 7])

#运算结果
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    r_untested = sess.run(r_4d)
    k_3d, w_3d = sess.run([k, w])

print(np.dot(k_3d[0,:,:],w_3d[:,:,0]))
#array([[0.68616796, 1.147416  , 1.2250627 , 1.0267124 , 0.5699807 ,
        0.65192497],
       [1.2962847 , 0.63438064, 1.7439795 , 1.2534602 , 0.8585079 ,
        0.9535629 ],
       [1.0780972 , 1.466816  , 1.623834  , 1.4493611 , 0.9913111 ,
        1.1141219 ],
       [0.6155605 , 1.0016347 , 0.95043844, 0.8071648 , 0.6317205 ,
        0.8374078 ]], dtype=float32)
print(r_untested[0,:,:,0])
#array([[0.68616796, 1.147416  , 1.2250627 , 1.0267124 , 0.5699807 ,
        0.65192497],
       [1.2962846 , 0.6343807 , 1.7439795 , 1.2534602 , 0.8585079 ,
        0.9535629 ],
       [1.0780972 , 1.4668161 , 1.623834  , 1.449361  , 0.9913111 ,
        1.1141219 ],
       [0.6155604 , 1.0016347 , 0.95043844, 0.8071648 , 0.6317204 ,
        0.8374078 ]], dtype=float32)


最终发现结果相同，大胆的用吧

如果是二维的矩阵相乘，那就跟平时咱们做的矩阵乘法一样：
a = torch.tensor([[1,2], [3,4]])

a
Out[31]: 
tensor([[1, 2],
        [3, 4]])
        
b = torch.tensor([[2,2], [3,4]])

b
Out[33]: 
tensor([[2, 2],
        [3, 4]])
        
torch.matmul(a, b)
Out[34]: 
tensor([[ 8, 10],
        [18, 22]])
        
torch.matmul(a, b).shape
Out[35]: torch.Size([2, 2])


如果维度更高呢？前面的维度必须要相同，然后最里面的两个维度符合矩阵相乘的形状限制：i×j，j×k。
a = torch.tensor([[[1,2], [3,4], [5,6]],[[7,8], [9,10], [11,12]]])

a
Out[37]: 
tensor([[[ 1,  2],
         [ 3,  4],
         [ 5,  6]],
        [[ 7,  8],
         [ 9, 10],
         [11, 12]]])
         
a.shape
Out[38]: torch.Size([2, 3, 2])

b = torch.tensor([[[1,2], [3,4]],[[7,8], [9,10]]])
b
Out[40]: 
tensor([[[ 1,  2],
         [ 3,  4]],
        [[ 7,  8],
         [ 9, 10]]])
         
b.shape
Out[41]: torch.Size([2, 2, 2])

torch.matmul(a, b)
Out[42]: 
tensor([[[  7,  10],
         [ 15,  22],
         [ 23,  34]],
        [[121, 136],
         [153, 172],
         [185, 208]]])

# a 和 b 的最外面的维度都是 2，相同。
# 最里面两个维度分别是 3 × 2 和 2 × 2，那么乘完以后就是 3 × 2
torch.matmul(a, b).shape
Out[43]: torch.Size([2, 3, 2])


这里举一个例子，在某一篇论文的代码中，作者使用matmul的场景。
简单地说，就是用过matmul()函数实现
假设有下面这么一个矩阵，shape为[batch_size, 1, seq_len]，该矩阵的含义是，最里面的每一个$[]_{seq_len}$表示一个句子的序列，如果元素为1，则表示该下标可以作为subject的head index。并且在每一行中，只有一个1。也就是只有一个subject的head index。
现在有另外一个矩阵，shape为[batch_size, seq_len, bert_dim]。该矩阵的含义是整个batch的text（[batch_size, seq_len]）经过经过bert encoder之后得到的。
根据前面说的，二者相乘，得到的shape是[batch_size, 1, bert_dim]。
比如第一行 $[0,1,0,....0,0]×bert encode之后的矩阵=[0.3, 0.1, ..., 0]$
最后得到的是subject在bert encode之后的空间中look up，或者说嵌入以后的向量。

context_vector = math_ops.reduce_sum(
              array_ops.reshape(attn_dist, [batch_size, -1, 1, 1]) * encoder_state, [1, 2])  # shape (batch_size, attn_size).

encoder_state: (batch_size,  attn_length, 1, attn_size) 

array_ops.reshape(attn_dist, [batch_size, -1, 1, 1]): (batch_size,  attn_length, 1, 1)

相乘结果为：  (batch_size,  attn_length, 1, attn_size)

https://blog.csdn.net/lanlana168/article/details/81136907

tensor二维与三维如何相加