所谓的内积(点积,数量积),代数意义总的来说就是向量对应位置的数做乘法然后求和,得到结果是一个数。
比如说3维空间中有两个向量a=(x1,y1,z1)和b=(x2,y2,z2)两个向量a =(x1,y1,z1)和b=(x2,y2,z2)两个向量a=(x1,y1,z1)和b=(x2,y2,z2),
则向量a・b=x1∗x2+y1∗y2+z1∗z2a・b=x1*x2+y1*y2+z1*z2a・b=x1∗x2+y1∗y2+z1∗z2
矩阵内积与向量内积同理,即两个同维度的矩阵对应位置上的数相乘(不过不求行列式),得到相同维度的矩阵的运算过程。
向量外积所谓的外积(叉积,向量积),概括地说,其运算结果是一个向量而不是一个标量。并且两个向量的外积与这两个向量组成的坐标平面垂直。
比如说3维空间中有两个向量a=(x1,y1,z1a =(x1,y1,z1a=(x1,y1,z1)和b=(x2,y2,z2)b=(x2,y2,z2)b=(x2,y2,z2),
则向量a×b=(x1,y1,z1)×(x2,y2,z2)=(y1z2−y2z1,z1x2−z2x1,x1y2−x2y1)a×b=(x1,y1,z1)×(x2,y2,z2)=(y1z2-y2z1,z1x2-z2x1,x1y2-x2y1)a×b=(x1,y1,z1)×(x2,y2,z2)=(y1z2−y2z1,z1x2−z2x1,x1y2−x2y1)
矩阵的外积,从代数运算上来说,就是大家在学线性代数的时候学的最基础的矩阵的叉乘,如[m∗n][m*n][m∗n]维的A矩阵叉乘[n∗t][n*t][n∗t]维的B矩阵,即A×B得到[m∗t][m*t][m∗t]维的C矩阵。
内外积的具体代码实现如下:
法一:用python中列表的形式来创建矩阵/向量'''
方法一:
用列表的形式创建矩阵/向量
用numpy的np.dot()函数计算行向量内外积
'''
import numpy as np
vector_a = [1,2,3] # 1行3列的行向量
vector_b = [2,3,4]
matrix_a = [[1,2], # 2行2列的2维矩阵
[3,4]]
matrix_b = [[2,3],
[4,5]]
# in_product_1:行向量a和行向量b的内积
in_product_1 = np.dot(vector_a,vector_b)
# in_product_2:矩阵A和矩阵B的内积
in_product_2 = np.multiply(matrix_a,matrix_b)
print("in_product_1:\n",in_product_1)
print("in_product_2:\n",in_product_2)
# out_product_1:向量a和向量b的外积
out_product_1 = np.cross(vector_a,vector_b)
# out_product_2:矩阵A和矩阵B的外积
out_product_2 = np.dot(matrix_a,matrix_b)
print("out_product_1:\n",out_product_1)
print("out_product_2:\n",out_product_2)
python输出结果为
in_product_1:
20
in_product_2:
[[ 2 6]
[12 20]]
out_product_1:
[-1 2 -1]
out_product_2:
[[10 13]
[22 29]]
法二:用np.array()来创建矩阵
'''
方法二:
用数组的形式创建矩阵
用普通的数乘*计算外积
用.dot()函数计算外积
'''
matrix_c = np.array([[1,2],
[3,4]]).reshape(2,2) # 创建一个
#2行2列的矩阵
matrix_d = np.array([[2,3],
[4,5]]).reshape(2,2)
# 相当于法一的 np.multiply()
in_product_3 = matrix_c * matrix_d
# 相当于法一的 np.dot()
out_product_3 = matrix_c.dot(matrix_d)
#
print("in_product_3:\n",in_product_3)
print("out_product_3:\n",out_product_4)
输出结果为:
in_product_3:
[[ 2 6]
[12 20]]
out_product_3:
[[10 13]
[22 29]]
法二中因为用np.array()的形式创建矩阵,所以内积不仅可以用法一的方法计算,还可以用普通的数乘*计算;外积不仅可以用法一的方法计算,还可直接A.dot(B)的形式表示矩阵A叉乘矩阵B。
在创建神经网络的时候大家经常会用到tensorflow,因为最近我也在学习tensorflow的使用方法,因此顺便把tensorflow的内积实现也贴在这里供大家参考:
法三:用tensorflow实现矩阵/向量外积import tensorflow as tf
matrix_1 = tf.constant([[1,2],
[3,4]]) #创建2*2的矩阵,为常量所以用tf.constant()
matrix_2 = tf.constant([[2,3],
[4,5]]) #创建2*1的矩阵,为常量所以用tf.constant()
in_ = tf.multiply(matrix_1, matrix_2) # 矩阵内积,相当于np.multiply()和*
out_ = tf.matmul(matrix_1, matrix_2) # 矩阵外积,相当于np.dot() 和.dot()
with tf.Session() as sess:
in_product_1 = sess.run(in_)
out_product_1 = sess.run(out_)
print("in_product_1:\n", in_product_1)
print("out_product_1:\n", out_product_1)
输出结果为:
in_product_1:
[[ 2 6]
[12 20]]
out_product_1:
[[10 13]
[22 29]]
对应向量/矩阵外积的matlab的程序为:
vector_a = [1, 2 ,3];
vector_b = [2, 3, 4];
matrix_a = [1,2;3,4];
matrix_b = [2,3;4,5];
# 2个行向量内积
in_product_1 = dot(vector_a, vector_b);
# 矩阵内积
in_product_2 = matrix_a.*matrix_b;
# 2个行向量外积
out_product_1 = cross(vector_a, vector_b);
# 矩阵外积
out_product_2 = matrix_a*matrix_b;
matlab的输出结果为:
in_product_1 =
20
in_product_2 =
2 6
12 20
out_product_1 =
-1 2 -1
out_product_2 =
10 13
22 29
细心的读者可能会发现,在matlab语句中,矩阵的外积没有用dot()函数而是直接用了乘号*,这里需要注意,matlab中的dot()函数表示矩阵的列向量的内积,因此如果求矩阵的外积直接用普通的数乘即可,若对上述矩阵用dot()函数,结果则为:
matrix_a = [1,2;3,4];
matrix_b = [2,3;4,5];
dot(matrix_a*matrix_b);
ans =
14 26
即14=1∗2+3∗4;26=2∗3+4∗514=1*2+3*4; 26=2*3+4*514=1∗2+3∗4;26=2∗3+4∗5
----------------------------------------分割线----------------------------------------
以上的例子中的所有向量均假设为行向量进行探讨,若向量为列向量,则可用np.array()初始化,对向量求转置,即可按上述方法继续求解。import numpy as np
vector_c = np.array([1,2,3]).reshape(3,1) # 创建3行1列的向量c
vector_c_T = vector_c.T #对向量c求转置
print("向量c为:\n",vector_c)
print("向量c的转置为:\n",vector_c_T)
输出结果为:
向量c为:
[[1]
[2]
[3]]
向量c的转置为:
[[1 2 3]]
ps.
写在最后,这是我第一次写博客,如果有写得不好的或者错误的地方欢迎指正。因为代码和文字全都是自己手工码出来,关键的地方也加了注释,所以如果需要转载请表明出处,谢谢大家。