内外积代数运算及python,tensorflow,matlab语句的实现

• 向量内积

所谓的内积（点积，数量积），代数意义总的来说就是向量对应位置的数做乘法然后求和，得到结果是一个数。
比如说3维空间中有$两个向量a=(x1,y1,z1)和b=(x2,y2,z2)$，
则向量$a・b=x1\ast x2+y1\ast y2+z1\ast z2$

• 矩阵内积

矩阵内积与向量内积同理，即两个同维度的矩阵对应位置上的数相乘（不过不求行列式），得到相同维度的矩阵的运算过程。

• 向量外积

所谓的外积（叉积，向量积），概括地说，其运算结果是一个向量而不是一个标量。并且两个向量的外积与这两个向量组成的坐标平面垂直。
比如说3维空间中有两个向量$a=(x1,y1,z1$)和$b=(x2,y2,z2)$，
则向量$a\times b=(x1,y1,z1)\times (x2,y2,z2)=(y1z2-y2z1,z1x2-z2x1,x1y2-x2y1)$

• 矩阵外积

矩阵的外积，从代数运算上来说，就是大家在学线性代数的时候学的最基础的矩阵的叉乘，如$[m\ast n]$维的A矩阵叉乘$[n\ast t]$维的B矩阵，即A×B得到$[m\ast 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\ast 2+3\ast 4;26=2\ast 3+4\ast 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.
写在最后，这是我第一次写博客，如果有写得不好的或者错误的地方欢迎指正。因为代码和文字全都是自己手工码出来，关键的地方也加了注释，所以如果需要转载请表明出处，谢谢大家。