m×n矩阵

m行n列 形成的数表 是 m×n矩阵

 
矩阵是有定语的，定语就是这是一个 几行几列 的矩阵

这个 m行n列 就是m×n矩阵的shape, 记为[m,n]

初学者提到矩阵时，尽量带上这个定语，哪怕嘴上不说出来，心里也要知道这是一个几乘几的矩阵

虽然AI计算或工程应用中，矩阵的维数通常高于2维，
但基本的运算，即真正的矩阵运算，实际上只有1维或2维，

1维矩阵，通常也被叫作 1×n矩阵(行矩阵)，n×1矩阵(列矩阵)
实际上，也是被当作2维矩阵来处理的 

矩阵相等

 
同型：
对于二维矩阵，两个矩阵的行数相等，且列数也相等

矩阵相等：
同型且两个矩阵相同索引位置上的元素皆相等 

两个经典矩阵

 
零矩阵：
所有元素为0，满足了元素相等，
但两个零矩阵是否相等，还得判断是否同型 

n×n单位矩阵E:
主对角线上的元素为1，其他元素为0
但两个单位矩阵E是否相等，还得看其是否同型 

矩阵的shape

 
同型就是要shape一致 

矩阵的shape,是个神奇的知识点，因为它看起来简单，不就矩阵的shape嘛，有多少行，多少列，这有何难？
实际上你转天就会忘记矩阵会有shape... 
遇到相关问题时，排查了好久才发现，哦...啊...呆了...居然是因为矩阵shape没弄明白导致的... 

矩阵数乘

一化万千

 
数与矩阵相乘，是数先化为与矩阵同shape的单值矩阵
然后，按乘相乘，不改变矩阵shape
是线性算法 

最小微粒/粒度是 单个维度的运算

 
矩阵可以看作由m个向量组成，每个向量n个维度 

矩阵数乘，直接看就是，一个数与向量各个维度的运算，
分步看，实际上先将单个的数据提升到同维向量的层面，
之后，就是向量的按位运算，该乘乘，该加加 

隐含的坐标系

 
现实世界，人的直观感知中，算一下两个点之间的距离，

比如，量一下身高之类的，直接拿个米尺过来，固定两点一拉，看看多长就行了

其他更复杂的距离，比如两个城市之间的距离，那就多拉几次，求个和... 

转化为数学的话，比如求直角三角形斜边的长，直观上还是拿个米尺拉一下... 
而在数学体系中，则是对斜边进行正交分解，分解成两个相互垂直的边，
而要成体系的话，还得定下一个多个事物之间 比较，定位的标准，
就是坐标系

而向量A(a1,a2)中的a1,a2可看作是xy平面坐标系x轴y轴上的数值 
数与向量相乘，实际上是数与坐标系中的每个维度上数据的计算

单维计算是向量运算的最小单位，
向量运算是矩阵运算的最小单位

为什么要一化万千

 
向量运算必须同维，具有相同维数的向量才可以进行运算 
一化万千是为了将两者的维数变成为一致 

为什么要按这种方式一化万千

 
现在的矩阵数乘是将单个数值 直接看作 单个维度 这个量纲上的数据
而不是人们直观上两点拉条线的那个连长，
即是坐标系中每个维上的数值，而不是到原点的距离 

不管一个事物有多少维，要作用，就同时作用于该事物的所有维

这实际上是一种业务含义上的等价转化
一个矩阵要乘以2，等价于矩阵中的每个向量都乘以2，因为矩阵由向量组成
一个向量要乘以2，等价于每个维度上的元素都乘以2吗？关键的是这一步 
回答了这个问题，就回答了以上所有问题 

以2维向量为例，2维向量，可以想象一条直角边在x轴，斜边一个点是原点的这个情况
斜边就是这个向量A(x,y)，x,y就是单维上的数值
凭什么是x,y要乘以2，而不是斜边乘以2? 
毕竟，从解析几何，直观上看，你说要让一段带方向的线段乘以2，我直接给它扩大一倍不就好了，
那为什么现在不这么做？或者说这么做的问题在哪里？
后续分析，暂时略...
或者说先跳过这个问题，看看周边问题 。。。 

向量的维数

 
[[[1]]]  3维向量
[[1]]    2维向量
[1]      1维向量
那1呢？
就是单个数值呢？是几维？
要知道[]只是一个形式，只是形式，形式
形式是什么？是极虚/纯虚的事物

再插一段无关紧要的内容，我这事物分四类，
有质为实，有质有形为阳实，有质无形为阴实（能量，波，电）
无质为虚，无质有形为阳虚(力,)， 无质无形为阴虚/极虚/纯虚(看事物的角度，方法论，知识，概念等)

有些事物我也难以分清，我只是初步这样分一下，后续再慢慢弄... 

纯虚

 
这里的形，我将它定义为形式的广义概念，
有形：有量的概念，可以进行加减运算，有叠加或消减的效果，
比如，没有人拉你，你不动，有人推你一把，就你会晃一下，用力拉，可能拉跑你
所以这里将力归于有形 

无形：不增不减，可以无限叠加而不增，可以无限复制而不减
比如复制一部电影，不管你复制出去多少份，原电影是不减的，那你复制出去的是什么？我将之定义为“无形”
比如知识的分享，并不会因为分享而减少，你若已知一个知识点，也不会因为别人分享给你而增多，
温故而知新，这个新是另外一个知识，也就是说，原来的那个知识，不增不减，
要么存在，要么不存在，是0与1的区别
这就是无质无形，纯虚，阴虚，极虚 

向量的维数，就是一个无形无质的事物，纯虚，
纯虚的事物，由于可以无限复制而不减，故可以一化万千 
但还没有解释，为什么要使用那个 正交分解/单维计算 的方式？

正交分解，单维计算，无疑是不自然的
或者说是计算机的计算方式，
即机器看世界跟人看世界的方式不一样 ... 

单个数值是几维？

 
[[[1]]]  3维向量
[[1]]    2维向量
[1]      1维向量
1        ？维
那1呢？
就是单个数值呢？是几维？

回答这个问题的前，要知道 维是一个纯虚的事物 
一个向量是否有一个维度，有就是有，没有就是没有，只是0与1的区别 

从形式上看，随着[]个数的减少，单个数值是0维，实际上各个AI框架也是这么定义的 
毕竟计算是落地计算，是要结果的

我这里要说的是另外一个层面，
单个数值可以是0维，也可以是任何维，
具体是多少维要看它在什么样的环境中，什么样的场景下 
比如一个点，是一个点
一条线上的某个点，也是一个点，
两条线的交叉点，也是一个点，
若点只是点，就是0维
若点在线上，虽然还是那个点，它就是1维
若点是二条线的交叉点，在这两条线确定的平面上，这个点都是2维，但注意啊，这个点还是那个点
是一个事物，只是因为场景的变化，形式上变了，点还是那个点 

即0,[0],[[0]]有相同的部分：即元素数值相等，
也有不同的部分，形式不同，维数不同 

那么单个数据是几维？
可以是任何维，但具体几维要看场景 

矩阵数乘为什么乘到矩阵的每个元素上？

 
比如，为什么不直接去乘那个直观的距离？
其实二者结果一致，比如
[1,1]斜边为根号2
2与[1,1]相乘为[2,2],2*2+2*2=8,开方后为2倍的根号2，等价于直接距离的2倍

对于多维，使用欧氏距离计算距离，将每个元素的公因子提取出来，等价于结果距离的公因子倍数 

这下总算理解为什么古人写的数学怎么那么难以阅读了，
因为平时看的文章都是配图的，都是一步步推导的，很少只用文字描述数学的

 
还有一个相似的地方，就是一个数与行列式相乘，等价的是与行列式中的 某一行/列 相乘
而不是与行列式所有元素相乘

这又是为什么？

这是因为行列式只是矩阵某个角度的一个描述，
矩阵是可以描述万物的，行列式只是体现了万物某个方面的性质

行列式的计算是 对角线法则，
矩阵隐藏着或者说有 维度正交 的味道，
即多维可由单维构成，复杂结构只是 简单线性结构 “摆摆角度，换个姿势” 呈现的一种状态 

行列式强调了复杂事物虽然由简单的单维构成，或者可由单维去描述，但这种构成/描述是融合于一体的
比如，任何一个三维，或者一个三维事物的任何一部分，都是三维，由三个维度构成/描述/表示 

看一个行列式，不能像看矩阵那样，一行行，一列列地看，
而是从对角线的角度去看，斜着看，看的是简单维度的元素变换到高维结构的过程... 

行列式是n阶方阵，任何一个多项式都是n个元素的乘积，
任何一行/列的元素 都涉及到了所有多项式，
所以，在任何一行/列上乘以一个数，就相当于乘到了整个行列式上 

小结

 
矩阵运算的最小单位是向量运算，
向量运算是单维运算，
向量运算是同维运算，必须维数相同才能一起运算 

矩阵相乘

 
1. 矩阵相乘，真正相乘的两个矩阵都是二维矩阵；
   更高维的矩阵相乘，也是转化为一个个二维矩阵进行相乘

2. 在理论上要求[m,s]@[s,n]
   即前一个矩阵的列 与后一个矩阵的行 维数相等

3. 在代码实现时，附加一条检验，两个矩阵的数据类型必须一致，比如要float都得是float

数据类型相同

 
import torch
m1 = torch.randint(low=1, high=7, size=(2, 3))
m2 = torch.randint(low=1, high=7, size=(3, 7))
m1 @ m2

tensor([[13, 16, 29, 21, 17, 29, 25],
        [25, 28, 37, 43, 31, 41, 41]])

数据类型不同

 
import torch
m1 = torch.randint(low=1, high=7, size=(2, 3))
m2 = torch.randint(low=1, high=7, size=(3, 7)).float()
m2.dtype
torch.float32

m1.dtype
torch.int64

m1@m2
RuntimeError: expected scalar type Long but found Float

向量运算

向量与矩阵的区别

 
向量是一种特殊的矩阵，也就是说，向量也是一个矩阵

书上印刷内容使用了各种括号去描述矩阵，
还把矩阵放的方方正正的，
但你心中要清楚，
只要你从一维的角度去看，就成向量，
从多维度的角度去看，就成矩阵

因为向量就是矩阵，所以，矩阵乘法也适用于向量，
并且矩阵乘法作用于向量时，又有一个专业的名字，或者说是等价的计算方法：向量内积 

向量一定是矩阵，但矩阵不一定是向量，
只有矩阵的维度为1时，才是向量 

向量的运算，除了内积，也叫点乘，还有线性运算：
加，减，数乘

向量线性运算:加，减，数乘

 
import numpy as np
a = np.array([0,1,0])
b = np.array([1,1,1])

a + b
array([1, 2, 1])

b - a
array([1, 0, 1])

3*a
array([0, 3, 0])

向量内积/点乘

 
a @ b = 0×1 + 1×1 + 0×1 = 1 

向量位乘

位乘：数乘的扩展

 
声明：
这一部分是个人自行扩展，
如果你是考研中被问到向量有哪些运算，
你回答线性运算（加，减，数乘），还有向量内积/点乘，可得满分，
不要回答什么位乘，
因为“位乘”这个概率是本人自己起的，作用范围只限于本网站 

位乘的来源：
向量的线性运算：加，减，数乘，都是向量在各自维度上的计算，
尤其是数乘，比如 3*a,实际上是
[3,3,3]*a = [3,3,3]*[0,1,0]= [0, 3, 0] 

在落地实现数学理论，就是计算机计算的时候，
发现计算的两个对象维数不一样，会先对低维数据进行升维
将3升为与a维数一致的向量[3,3,3],
先维数达到一致，然后再计算 

那么，当另外一向量b=[1,2,3],b*a应该怎么算？
顺着这个思路，也应该在各自的维度上计算，
b*a = [1,2,3]*[0,1,0] = [1*0,2*1,3*0] = [0,2,1]
这种计算方法，与线性运算的思想一致，就是
两个向量维度相同，然后在各自的维度上计算，同时不改变原有维度，
但它又与数乘有明显的区别，
故，个人叫这种运算为 “位乘”

位乘在计算机中的使用

 
import numpy as np
a = np.array([0,1,0])
b = np.array([1,1,1])
a*b
array([0, 1, 0])

位乘运算早在计算机中已经实现，
只是个人没有在官方教材中找到这种叫法，
故而擅自起了个名字：“向量位乘”

位乘在AI的意义

 
从纯数学的角度看，
乘法的本质是加法，除法的本质是减法，减法的本质还是加法 
加法的本质是：相互作用（这也是个人观点，如有雷同，纯属巧合...毕竟书读多了，就会有点想法，不喜勿喷...）
提到相互作用，很容易想到“力”的概念，
从力的角度看，就是 “同我着，效果为增；逆我者，效果为减”

只是，相互作用的方式非唯一，虽说大道殊途同归，条条大道通罗马，
但不同的方法的效率不一样，
事物以万千形态展示，不同形态的存在，有它存在意义 

大多情况下，乘法的效率比加法高的多，快的多 
比如，1+2+3+...+n ,远没有n(n+1)/2 计算的快，虽然它们结果相等 

本网站的数学是围绕AI展开的，先不扯别的，
在AI中认为全体数据集为1,局部/个体样本 都小于1 
向量位乘 实际上各个维度的数据，都是小于1的数在相乘 
比如，0.3×0.05 = 0.015，这是一个越乘越小的趋势 
在AI中，认为这个0.015是某个维度中，代表0.3的事物，与代表0.05事物的共性 

位乘就是事物各个维度上的相互作用，
在AI中又有提取各个维度共性的作用

向量单位化

方差

 
import torch
a=torch.tensor([1,2,3],dtype=torch.float32)
a.var()
tensor(1.)

向量单位化

 
import torch
a=torch.tensor([1,2,3],dtype=torch.float32)
l2_a = torch.sqrt(torch.sum(a*a))
b=a/l2_a
b
tensor([0.2673, 0.5345, 0.8018])

torch.sqrt(torch.sum(b*b))
tensor(1.0000)

二者区别

 
方差重点是整个分布相对分布中心偏离程度

向量单位化，就是长度归于一，是要向量各维度除以向量本身/整体的长度

矩阵的维度

数学理论上矩阵的维度

 
在数学理论上，矩阵就是一堆数（数表）
这堆数，讲究的是维度，以何种维度去看这堆数 

一个数，它是矩阵吗？
它是矩阵
它是多少维，要看你怎么从多少个维度去看它
比如，1 
[1] 以列表形成写，它是1维的
[[1]] 是2维
[[[1]]] 是3维 
但它们都只有一个数，
直接写成 1 ，也是一个数，也是矩阵

所以，矩阵的维度，是有对应的业务含义的，
就单纯的一堆数来说，没有赋予它业务含义之前，
你说它没有维度也行，说它1维也行，2维也行 

一堆数有了业务含义之后，也就有了维度，
数还是那堆数，
不因你用大括号 括它，或者中括号括它而发生改变, 
那是学术研究约定的形式/方法 
比如一规律，动能定理，你用汉语描述还是法语描述，动能定理这个规律是不变的

落地计算pytorch中的维度

 
标量：单个数，维度为0 
import torch
a=torch.tensor(1)
a.ndim
0

向量：列表/一维数组， 维度为 1 
import torch
a=torch.tensor([1])
a.ndim
1

矩阵：向量组/二维数组，维度为2 
import torch
a=torch.tensor([[1,1],[1,2]])
a.ndim
2

大多数交流沟通场景中，
矩阵指二维数组，
一组数组就说是向量，
单个数就说标量，
高于二维的矩阵，说是 张量tensor 

实际上张量tensor，可以是 单个数，向量，矩阵 的任意一种 
同时，矩阵虽说通常指二维数表，但更高维的数表当然也是矩阵 

矩阵的转置

教材/官方/面试说法

 
交换行列的维度后就是它的转置矩阵了

以下内容纯属个人猜想，初学者先不要看

 
交换行列的维度后就是它的转置矩阵了，目前只谈二维矩阵 

对于二维，坐标系就是常见的xy平面坐标系 

一个向量，转动90度后，就是它的转置矩阵

一个矩阵，所有向量，以主对角线为中心，转动90度， 
效果上/外观上 相当于以主对角线为中心，翻转一下 

在二维平面坐标系中看矩阵乘法：
向量a=[0,1]在y轴上
向量b=[1,0]在x轴上
如果它们相乘就是0，但转置转的这90度显示不是坐标系中的这个90度，
一个矩阵转动90度后，就是交换维度后，必能与自己相乘，
矩阵相乘时，就有正交的意思，是后面的向量转动90度后才与前一个矩阵的向量相乘的
转置转动的90度，经矩阵乘法，又被转回去了

转置将一个列向量变为行向量，而矩阵相乘必是（一个行向量与一个列向量/一个列向量与一个行向量）的内积运算，

即矩阵运算实际上是向量内积运算，而向量内积运算，必是两个正交的向量 

虽然没有在书上找到明确说明的地方，但个人发现：
所有矩阵运算，全是向量内积，全部限定于二维空间，
如果有三维，那其中一个维度必定是批次，指多少这样的二维矩阵，真正进行向量内积的还是二个相互垂直的向量

这种垂直并非坐标系中的垂直，如果非要以坐标系来描述，那就是：
二维平面直角坐标系中的一个向量，想要与自己进行矩阵相乘，它需要：
先转90度得到一个转置向量，进行矩阵乘法运算时，再逆转90度，又变回自己，然后按位相乘再相加

一个向量不转90度就与自己相乘，那是线性运算，只是按位相乘
矩阵乘法为什么要，或者说向量内积为什么要两个垂直的向量才能计算？
即为什么要写成[2,3]@[3,4]
而不是
[2,3]@[4,3]
但计算方式仍是一样的计算方式（原来正统是行与列相乘，换了形式之后向量内积改为行与行相乘再相加就行了），
数还是那堆数，也不影响它们的结果
本人不知道为什么，在大脑中推演对比了这两种方式，其结果当然都是一样的，
但隐隐感觉的还是目前“正统”的这种，有正交垂直之意的形式，更自然一些 

一个向量在平面直角坐标中的数值是不变的，不管它转不转置
但转置的确有垂直之意，
在这里，本人大胆地针对 这个场景，增加一个维度，来描述这个问题
列向量转90度，这个90度并不在平面直角坐标系这个层面，是一个新的维度上，第三个维度
一个向量与它的转置向量在平面直角坐标系中的投影是重合的，
它们本就是一个事物，只是看它们的角度不同 
而在第三个维度中，它们是不同的，是垂直的

就像两个长方体砖块，横着放，竖着放，都是这两个砖块，但要它们无缝对接，就必须两个面完全一样
这个问题投影到2维平面上就是，两个矩形想要无缝对接，对接的两个边必须一致，并且对接后对接的边的维度消失

两个2维矩阵相乘，转不转90度，都是这两个矩阵，但要相乘，就必须首尾两个维数相同，相乘后对接的维数消失

这不上学之后，终于不用管那什么学分和考试了，有什么想法就大胆思考，怎一个痛快了得!!! 

以上纯属个人猜测，如有雷同，纯属巧合... 

参考

    
    数学技巧篇29：向量运算法则