线性代数怎么学

作者：「已注销」
链接：https://www.zhihu.com/question/311724817/answer/695067704
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

线性代数其实不难学，但是某些脑残的教材导致了大家觉得线性代数难学。对，我说的就是同济版，居然用行列式来起手线性代数学习，一开始逆序数定义就来得莫名其妙，然后那一大坨行列式的定义式更让人望而生畏，后面再来一大篇幅的各种花式求行列式，当年作为一个萌新的我，直接就丧失了学习线性代数的信心以及兴趣了。吐槽完毕。

要学好线性代数，最重要的是抓住线性代数的主线。线性代数的主线就是线性空间以及线性映射，整个线性代数的概念公式定义定理都是围绕着线性空间以及线性映射展开的。你要做的，就是紧紧抓住这条主线，把线性代数的所有知识点串联起来，然后融会贯通，自然就能学好线性代数了。

1，线性空间。线性空间的定义比较抽象，简单的说，就是向量组成的一个集合，这个集合可以定义加法以及纯量乘法，并且对加法以及乘法满足交换律结合律以及分配率。这个集合以及定义在集合上的代数运算就是线性空间。

研究线性空间有几个途径，一是基与维数，二是同构，三是子空间与直和以及商空间，四是线性映射。

先讲讲基与维数。一个线性空间必定存在基，线性空间的任意元素都可以由基线性表出，且表出方式唯一，这个唯一的表出的组合就是这个元素在这个基下的坐标。线性表出且表出方式唯一的充分必要条件是什么？这里又引出了线性无关以及极大线性无关组的概念，极大线性无关组元素的个数又能引出秩的概念。由秩又能引出维度的概念。以上这些概念都是为了刻画线性空间的基与维数而衍生出来的，并不是凭空出现无中生有的。

下面再谈谈同构。线性空间千千万，应如何研究呢？同构就是这样一个强大的概念，任何维数相同的线性空间之间是同构的，空间的维数是简单而深刻的，简单的自然数居然能够刻画空间最本质的性质。借助于同构，要研究任意一个n维线性空间，只要研究Rⁿ就行了。

n维线性空间作为一个整体，我们自然想到能不能先研究它的局部性质？所以自然而然的导出了子空间的概念以及整个空间的直和分解。直和分解要求把整个空间分解为两两不交的子空间之和，通过研究各个简单的子空间的性质，从而得出整个空间的性质。

2，线性映射。

前面讲了线性空间，舞台搭好了，轮到主角：线性映射登场了。

线性映射的定义这里就不赘述了。我们小学就学过正比例函数y=kx，这是一个最简单的一维线性映射，也是一个具体的线性映射'模型'，线性映射的所有性质对比着正比例函数来看，一切都是那么简单易懂。现在把定义域从一维升级到多维，值域也从一维升级到多维，然后正比例系数k也升级为一个矩阵，那么这个正比例函数就升级为一个线性映射了。

1)线性映射的核空间。这是线性映射的一个重要的概念，什么是线性映射的核空间呢？简单的说，就是映射到零的原像的集合，记作KER。用正比例函数来类比，显然当k不等于0时，它的核是零空间，当k为零时，它的核空间是整个R。

有时候需要判定一个线性映射是不是单射，按照定义来还是没那么好证的，这时我们可以从它的核来判定，只要它的核是零，那么这个线性映射必然是单射。

2)线性映射的像。当自变量取遍整个定义域时，它的像的取值范围成为一个线性子空间，称为像空间，记作IM。

3)线性映射的矩阵表示。一个抽象的线性映射应如何'解析'的表达出来呢？这个表达式写出来就是一个矩阵，且这个矩阵依赖于基的选择。也就是说在不同的基下，线性映射有不同的矩阵。基有无穷个，相应的矩阵有无穷个。这就给用矩阵研究线性映射带来了麻烦。

幸好我们有相似矩阵。同一个线性映射在不同的基下的矩阵是相似关系，相似不变量有秩，行列式，迹，特征值，特征多项式等。所以可以通过相似矩阵来研究线性映射的秩，行列式，迹，特征值，特征多项式等性质。

线性映射的矩阵有无穷多，那么这其中有哪些是值得关注的呢？第一就是标准正交基下的矩阵了，这也是最常见的。

然而一个线性映射的矩阵在标准正交基下可能特别复杂，所以需要选择一组特殊的基，让它的矩阵在这个基下有最简单的矩阵表示。如果存在这样的基，使得线性映射的矩阵为对角矩阵，则称这个线性映射可对角化。

然而是不是所有线性映射都可以对角化呢，遗憾的是，并不是。那么就要问，如果一个线性映射不能对角化，那么它的最简矩阵是什么？这个问题的答案是若尔当标准型。可以证明，在复数域上，任何线性映射都存在唯一的若尔当标准型。

=====================================================================

机器学习

=====================================================================

研究线性空间有几个途径，一是基与维数，二是同构，三是子空间与直和以及商空间，四是线性映射。

2，线性映射。

前面讲了线性空间，舞台搭好了，轮到主角：线性映射登场了。

2)线性映射的像。当自变量取遍整个定义域时，它的像的取值范围成为一个线性子空间，称为像空间，记作IM。

线性映射的矩阵有无穷多，那么这其中有哪些是值得关注的呢？第一就是标准正交基下的矩阵了，这也是最常见的。

============================================================

https://xiaozhuanlan.com/LinearAlgebra/4950187326

张雨萌-酱油哥的《机器学习线性代数核心》

这本书试读了一章，还是值得推荐的，大家可以去在线购买，以上是链接

============================================================

作为写在全书前面的序言，我们重点来回答这三个问题：

1、为什么要学习线性代数？
2、应该如何学习线性代数？
3、选择在哪学习线性代数？

1.为什么要学习线性代数

当下，机器学习、人工智能的火爆程度可以说是无需多言，薪酬之高、职业发展道路之宽阔吸引着大量优秀的学子投身于这个领域进行学习和探索。

然而，与较为基础的程序语言、编程框架不同，机器学习是一个更为综合性的学科领域，一个零基础的小白想要轻易涉足并非易事，因为他需要有大量的前序知识作为铺垫，其中最核心的基础就是以线性代数、概率统计等为代表的数学知识和思想方法。

线性代数作为利用空间来投射和表征数据的基本工具，可以方便的对数据进行各种变换，从而让研究人员更为直观、清晰的探查到数据的主要特征和不同维度的所需信息。因此，线性代数的核心基础地位不言而喻，只有熟练的运用好这个工具，才能为自己搭建起攀登机器学习的牢固阶梯。

初学者可能会问了，机器学习、数据分析中有哪些地方需要用到线性代数呢？有很多，我们略举几例，例如：

1、如何来量化描述日常生活中的事物，比如个体的不同属性、自然语言的词语句子等等，来支撑我们所要进行的算法分析？

2、如何将待处理的数据在不同维度的空间中进行变换处理，以寻找到最佳的观测角度，使得数据处理达到最好的效果？

3、如何从采样的海量数据中提取出主要特征成分，梳理出数据的主要脉络，从而指导你对一个文本进行主题建模，帮助你利用协同过滤技术成功推荐给用户最喜爱的菜肴？

4、如何用数字表示图像，并且在不太影响观察效果的前提下，利用很小的存储空间就能近似的达到原有图像的视觉效果？

5、如何对我们采集到的观测数据进行拟合，找到其中暗含的规律，指导对未知数据的预测？

6、在实际的数据采样分析过程中，如何在无法找到精确解的情况下，探索到最接近真相的近似解？

等等等等，还有很多......

这些实用而有趣的问题，我们在数据分析和机器学习中几乎是每天都要遇到，而想要解决好这些问题，线性代数的核心概念和处理方法都是必须牢固掌握的。

2.应该如何学习线性代数

既然明确了线性代数的核心基础地位，那么很多同学一定摩拳擦掌，磨刀霍霍准备大干一场，但是翻开大学里的线性代数教材，就会感觉有些迷茫，从教材里，似乎很难找到解决上述实际问题的方法。

绝大多数同学在大学学习的时候都会有这样一个感觉，一门课学完了，考试过了，却不知道学了有什么用，尤其是数学类的课程。因为传统教材大多数是按照定义-例题-计算来大篇幅罗列数学概念，风格偏理论定义和运算技巧，没有注重梳理学科内在的逻辑脉络，更没能深刻挖掘学科与当下前沿技术的交汇点，往往应付考试有余，但想以此高效的打下机器学习的数学基础，针对性和可读性不佳。

明确了不足，那就应该在传统教材的薄弱环节做突破，设计一条有针对性的学习路径：

一方面，紧紧围绕空间变换这个线性代数的主要脉络，从坐标与变换、空间与映射、近似与拟合、相似与特征、降维与压缩这五个维度，环环相扣的展开线性代数与机器学习算法紧密结合的最核心内容，深刻理解如何用空间表示数据、用空间处理数据、用空间优化数据，用一条线索拎其整个学科主干内容。

另一方面，结合机器学习中的典型实战案例，面向应用将线性代数这一数学工具用熟用好，同时以Python语言为工具进行数学思想和解决方案的有效实践，无缝对接工程应用。

3.选择在哪学习线性代数

学习的路径明晰了，而传统大学教材却都不是按照这个套路来编写，该怎么办？别急，作者依照上述学习路径并结合自身的思考与感悟，精心设计了《机器学习线性代数核心》这一全新教程。

来，我们一起看看这套教程吧！

3.1.作者简介

作者：酱油哥，2014年清华大学计算机科学与技术系硕士毕业，主要研究兴趣方向为数据分析、自然语言处理。专业基础扎实，尤其擅长深入浅出的讲解技术，知乎专栏《给妹子讲python》关注量近14000，深受读者的好评与期待。

3.2.全书内容安排如下：

第一部分坐标与变换：高楼平地起。从空间坐标表示与线性变换入手，快速建立线性代数直观感受，理解向量和矩阵运算的几何本质；

第二部分空间与映射：矩阵的灵魂。围绕线性代数的概念基石---空间，详细阐述空间中映射和变换的本质，深入剖析矩阵在其中的灵魂作用；

第三部分近似与拟合：真相最近处。展现线性代数在近似与拟合中的理论基础，并讲述了最小二乘法的实际应用；

第四部分相似与特征：最佳观察角。重点分析矩阵的相似性以及特征的提取方法，打好数据降维的理论基础；

第五部分特征与降维：抓住主成分。作为全书知识脉络的交汇，讲解如何对数据进行降维和特征分析，深入剖析矩阵分析的核心内容：特征值分解和奇异值分解；

第六部分实践与应用。展现线性代数在图像压缩、推荐系统分析中的实际应用。

3.3.本书的三个特色：

第一，避免纸上谈兵。全书以Python语言作为工具进行概念和方法的有效实践，无缝对接机器学习工程应用，可操作性强；

第二，避免生硬枯燥。务求结合线性代数的几何意义进行重点概念的剖析和演绎，避免传统教材的既视感，强化逻辑性和可读性；

第三，避免大水漫灌。以机器学习所急需的线性代数内容为立足点，精确打击，提高效率。

如何你选择和我们一起出征，去征服机器学习的线性代数核心，那就让我们翻开新章节，一起出发吧！

=======================================================

第 2.1 章描述空间的工具：向量

提示：如果在手机端或PC端，公式无法正常显示，请再次刷新就可以了

1.行向量、列向量及python表示

1.1.重温向量

向量对于大家而言一定不会陌生，向量的概念很简单，把数字排成一行或一列就是向量。他可以作为对空间进行描述的有力工具。

比如：一个简单的二维向量： $[\begin{matrix} 4 \\ 5 \end{matrix}]$

图1.1 二维向量的表示

图1.2 三维向量的表示

当然，向量也不仅仅局限于描述空间中的点坐标和有向线段，他也可以作为描述事物属性的一种便捷工具和基础的数据表示形式。比如一次考试，你的成绩为：语文85分，数学92分，外语89分。由于这三门课分属于你的不同科目属性，因此我们可以使用一个三维向量对其进行表示： $s c o r e = [\begin{matrix} 85 \\ 92 \\ 89 \end{matrix}]$

又如，在自然语言处理中，程序在进行文本阅读时，首先就会进行文本分词，然后使用向量进行表示。这是因为向量很适合在高维空间中进行表达和处理。在本书后续章节中将接触到的机器学习有关概念：如投影、降维等等，都是在向量的基础上实现的。

1.2.我们通常使用列向量

根据刚才我们所讲的，把数字排成一行或一列就是向量。因此向量拥有两种表达方式：像 $[\begin{matrix} 4 \\ 5 \end{matrix}]$

我们在实际使用向量工具进行描述和计算的时候，具体使用哪一种方式呢？在没有特殊说明的情况下，我们提到向量，都是默认为列向量。在文字排版的时候，由于列向量比较占空间，因此一般将其写成行向量的转置： ${[\begin{matrix} - 4 & 15 & 6.7 \end{matrix}]}^{T}$

如果我们从直觉上来看，似乎行向量更为直观呀，这里为什么如此偏爱列向量呢？这么做主要是为了方便后续的向量坐标变换、映射等计算。这里只简单提一句，大家有个直观印象就好：将一个矩阵 $A$

1.3.用python来表示向量

那么好，现在我们把工具用起来。对应的，我们如何用python语言来表示行向量和列向量呢？这里我们需要解决python数据分析中的一个常用工具库：Numpy。

先看一段代码：

代码片段:

import numpy as np
A = np.array([1,2,3,4])
print(A)

运算结果：

[1 2 3 4]

python中用Numpy库来生成一个向量，默认生成的是行向量，但正如我们上面所说的，一般情况下我们通常使用的是列向量，因此还需要对其做一些处理。

你的第一感觉可能会想，用一用转置这个概念（后面会详细讲解）是不是就可以了，也就是把向量的行索引和列索引交换位置，但是Numpy中的转置方法在一维向量里是无效的。

代码片段:

import numpy as np
A = np.array([1,2,3,4])
print(A.transpose())

运行结果：

[1 2 3 4]

我们发现，确实起到效果。那我们应该如何来表示一个列向量呢？具体的做法我们来演示一下：

代码片段：

import numpy as np
A = np.array([1, 2, 3, 4])
A_t = A[:, np.newaxis]
print(A_t)
print(A_t.shape)

运行结果：

[[1]
[2]
[3]
[4]]
(4, 1)

这样，我们就把一个行向量转换成列向量了。这里确实是用了转置的想法，但是代码看上去怪怪的，有点略复杂。那有没有更简单的方法？有，慢慢往下看。

1.4.如何简单生成列向量

这里我们也事先用一点后面的知识，我们把向量看作是一维的数组，但是也可以看做是行为1或者列为1的二维数组，用后面的内容来描述，即向量可以看作是特殊的矩阵。行向量是 $1 \times m$

代码片段：

import numpy as np
A = np.array([[1, 2, 3]])
print(A)
print(A.T)

运行结果：

[[1 2 3]]
[[1]
[2]
[3]]

在这段代码里，我们要注意：行向量初始化时，我们使用了Numpy库中的二维向量初始化方法，因此多嵌套了一层中括号，在这种情况下，我们就可以直接通过行向量转置的方法，来生成对应的列向量了，是不是简单了许多！

2.用向量去计算：加法、数量积和向量乘法

明确了向量的表示方法，那么接下来我们来梳理一下向量的基本运算，我们逐一介绍向量的加法、向量的数量积和向量间的乘法。

2.1.向量的加法

两个维数相同的向量才能进行加法运算，将相同位置上的元素相加即可，结果向量的维数保持不变：

${[\begin{matrix} u_{1} & u_{2} & u_{3} \end{matrix}]}^{T}$

向量的加法运算很简单，我们具体来举个例子：

代码片段：

import numpy as np
u = np.array([[1,2,3]]).T
v = np.array([[5,6,7]]).T
print(u + v)

运行结果：

[[ 6]
[ 8]
[10]]

2.2.向量的数量乘法

向量的数量乘法就是将参与乘法运算的数和向量的每个元素分别相乘，结果向量保持维数不变，数量乘法就是将向量沿着所在直线的方向拉长到相应的倍数，方向和参与运算的数字的正负号相关：

c ${[\begin{matrix} u_{1} & u_{2} & u_{3} \end{matrix}]}^{T}$

代码片段：

import numpy as np
u = np.array([[1, 2, 3]]).T
print(3*u)

运行结果：

[[3]
[6]
[9]]

2.3.向量间的乘法

介绍完向量的加法和数量乘法，这里大家一定会问了，那向量和向量相乘呢？向量与向量的乘法分为所谓的点乘（内积）和叉乘（外积），我们先说内积。

2.3.1.向量的内积

向量 $u$

$u \cdot v = {[\begin{matrix} u_{1} & u_{2} & u_{3} \end{matrix}]}^{T} \cdot {[\begin{matrix} v_{1} & v_{2} & v_{3} \end{matrix}]}^{T} = u_{1} v_{1} + u_{2} v_{2} + u_{3} v_{3}$

这个定义看上去很简单，好像没什么特殊含义。但是，他的另一种表示方法所含的物理意义就十分清晰： $u \cdot v = | u | | v | c o s θ$

图1.3 向量内积的几何表示

需要注意的是，我们在实际计算向量内积时，无论是行向量间的内积还是列向量间的内积，其运算结果都是一样的。

python中计算向量的内积非常方便。但是需要注意，如果我们直接使用numpy函数库中的内积方法dot，那么python内积运算函数dot中的参数要求必须是一维行向量：

代码片段：

import numpy as np
u = np.array([3, 5, 2])
v = np.array([1, 4, 7])
print(np.dot(u, v))

运行结果：

那么有人可能会问了，在上文中我们学习了表示行列向量的通用方法（即用行或列为1的二维数组表示向量），用在这里行不行？我们可以看看：

代码片段：

import numpy as np
u = np.array([[3, 5, 2]])
v = np.array([[1, 4, 7]])
print(np.dot(u,v))

运行结果：

Traceback (most recent call last):
File "E:/12homework/12homework.py", line 5, in <module>
print(np.dot(u,v))
ValueError: shapes (1,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)

代码片段：

import numpy as np
u = np.array([[3, 5, 2]]).T
v = np.array([[1, 4, 7]]).T
print(np.dot(u,v))

运行结果：

Traceback (most recent call last):
File "E:/12homework/12homework.py", line 5, in <module>
print(np.dot(u,v))
ValueError: shapes (3,1) and (3,1) not aligned: 1 (dim 1) != 3 (dim 0)

看上去似乎有些问题，学完整个第一章大家就会知道，这种向量的表示方法本质上其实是矩阵，只不过是行数或者列数为1的特殊矩阵，将这种方法表示下的向量作为dot函数的参数，就需要依据矩阵的乘法法则来计算，依据矩阵乘法法则判定就会报错，至于为什么会出错，后面的小节会重点讲述，那么怎么样才能得到正确的结果呢，这里先提前预告一下：

代码片段：

import numpy as np
u = np.array([[3, 5, 2]])
v = np.array([[1, 4, 7]]).T
print(np.dot(u,v))

运行结果：

[[37]]

看上去得到了一个正确的数值结果，至于为什么外面围着两层中括号，学完本章就会明白。

2.3.2.向量的外积

至于说向量的外积，我们只讨论二维平面和三维空间中的向量外积：

在二维平面中： $u \times v = {[\begin{matrix} u_{1} & u_{2} \end{matrix}]}^{T} \times {[\begin{matrix} v_{1} & v_{2} \end{matrix}]}^{T} = u_{1} v_{2} - u_{2} v_{1}$

我们同样的，还有另一种表达式，看起来物理意义会更直观一些： $u \cdot v = | u | | v | s i n θ$

图1.4 向量外积的几何表示

代码片段：

import numpy as np
u = np.array([3, 5])
v = np.array([1, 4])
print(np.cross(u, v))

运行结果：

而在三维空间中，外积的计算要相对复杂一些，其计算的结果是一个向量而不是一个数值。

$u \times v = {[\begin{matrix} u_{1} & u_{2} & u_{3} \end{matrix}]}^{T} \times {[\begin{matrix} v_{1} & v_{2} & v_{3} \end{matrix}]}^{T} = {[\begin{matrix} u_{2} v_{3} - u_{3} v_{2} & u_{3} v_{1} - u_{1} v_{3} & u_{1} v_{2} - u_{2} v_{1} \end{matrix}]}^{T}$

这个向量也是有物理含义的，即两个向量所表示平面的法向量。

代码片段：

import numpy as np
x = np.array([3, 3, 9])
y = np.array([1, 4, 12])
print(np.cross(x, y))

运行结果：

[ 0 -27 9]

3.先数乘后叠加，向量的线性组合

在向量加法和数量乘法的基础上，我们将其组合应用，来介绍一下向量的线性组合。针对向量 $u$

我们再来举一个实际例子来看一下三个三维向量的线性组合： $u = {[\begin{matrix} u_{1} & u_{2} & u_{3} \end{matrix}]}^{T}$

$c u + d v + e w = c [\begin{matrix} u_{1} \\ u_{2} \\ u_{3} \end{matrix}] + d [\begin{matrix} v_{1} \\ v_{2} \\ v_{3} \end{matrix}] + e [\begin{matrix} w_{1} \\ w_{2} \\ w_{3} \end{matrix}] = [\begin{matrix} c u_{1} + d v_{1} + e w_{1} \\ c u_{2} + d v_{2} + e w_{2} \\ c u_{3} + d v_{3} + e w_{3} \end{matrix}]$

其中， $c$

在这里，我们也举个例子来对几个已知的向量进行线性组合：

代码片段：

import numpy as np
u = np.array([[1, 2, 3]]).T
v = np.array([[4, 5, 6]]).T
w = np.array([[7, 8, 9]]).T
print(3*u+4*v+5*w)

运行结果：

[[54]
[66]
[78]]

那么进一步，我们思考一下如下的几个线性组合的图像是什么？我们知道，两个向量相加，在几何上就是将两个向量首尾依次连接，结果向量就是最初的起点和最终的终点的有向连线。我们假定有三个非零的三维向量： $u = {[\begin{matrix} u_{1} & u_{2} & u_{3} \end{matrix}]}^{T}$

情况一， $c u$

图1.5

c u

情况二， $c u + d v$

图1.6 向量u和v不共线时，

c u + d v

当向量 $u$

情况三， $c u + d v + e w$

不难发现，我们在讨论上述多种情况时，反复提到了共线、共面的概念，这些性质会对一组向量线性组合的结果向量的空间位置分布产生较大影响，是线性代数中非常关键的概念，在后续章节中，我们会围绕他开展深入的讨论，不过我们会使用更加专业的词汇来进行描述和介绍，即：线性相关和线性无关。

==================================================

只是试读推荐，所以只推荐2篇，更多大家自己到上面链接去购买

==================================================

第 2.3 章矩阵，让向量动起来

1.矩阵：排列的向量，堆放的数

介绍完了向量，这一节我们开始介绍矩阵。对于矩阵而言，最直观的描述就是一个 $m \times n$

我们举一个例子：一个 $2 \times 3$

那如果我们想使用Python语言来表示上面这个矩阵，也是非常简单的。可以使用NumPy中的嵌套数组来完成，这个矩阵本质上被表示成了一个二维数组：

代码片段：

import numpy as np
A = np.array([[1, 2, 3],
[0.4, -4, 2]])
print(A)
print(A.shape)

运行结果：

[[ 1. 2. 3. ]
[ 0.4 -4. 2. ]]
(2, 3)

我们着重强调一下，在形容矩阵规模的时候，一般采用其行数和列数来进行描述，对应到代码中，我们通过矩阵 $A$

2.特殊形态的矩阵

初步接触过上一小节里那个普普通通的 $2 \times 3$

2.1.方阵

行数和列数相等的这类矩阵，我们称之为方阵，其行数或列数称之为他的阶数，这里我们看到的就是一个 $3$

import numpy as np
A = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print(A)
print(A.shape)

运行结果：

[[1 2 3]
[4 5 6]
[7 8 9]]
(3, 3)

2.2.矩阵转置与对称矩阵

在说到对称矩阵之前，我们先得说一下矩阵的转置。对于矩阵 $A = [\begin{matrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{matrix}]$

代码片段：

import numpy as np
A = np.array([[1, 2, 3],
[4, 5, 6]])
print(A)
print(A.T)

运行结果：

[[1 2 3]
[4 5 6]]
[[1 4]
[2 5]
[3 6]]

那么，如果原矩阵和转置后新得到的矩阵相等，那么这个矩阵我们就称其为对称矩阵。显然，矩阵对称的前提必须得是一个方阵，其次在方阵 $S$

代码片段：

import numpy as np
S = np.array([[1, 2, 3],
[2, 5, 6],
[3, 6, 9]])
print(S)
print(S.T)

运行结果：

[[1 2 3]
[2 5 6]
[3 6 9]]
[[1 2 3]
[2 5 6]
[3 6 9]]

在对阵矩阵中我们发现，沿着从左上到右下的对角线相互对称的元素都是彼此相等的。在后面的内容中你会不断发现：将对称矩阵称之为最重要的矩阵之一，丝毫不为过。他在矩阵的相关分析中会扮演极其重要的角色。

2.3.向量：可以看作一维矩阵

前面在介绍向量的时候，我们提到过这个概念。现在介绍了矩阵之后，我们再着重回顾一下： $n$

那么这样做的目的是什么呢？一方面可以将矩阵和向量的python表示方法统一起来，另一方面，在马上要介绍的矩阵与向量的乘法运算中，也可以将其看作是矩阵与矩阵乘法的一种特殊形式，将计算方式统一起来。我们再次用这个视角重新生成一个新的行向量和列向量。

代码片段：

import numpy as np
p = np.array([[1, 2, 3]])
print(p)
print(p.T)

运行结果：

[[1 2 3]]
[[1]
[2]
[3]]

我们用生成矩阵的方法生成了一个 $1 \times 3$

2.4.零矩阵

顾名思义，所有元素都是 $0$

代码片段：

import numpy as np
A = np.zeros([3, 5])
print(A)

运行结果：

[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]

2.5.对角矩阵

非对角元素位置上全部为 $0$

代码片段：

import numpy as np
A = np.diag([1, 2, 3])
print(A)

运行结果：

[[1 0 0]
[0 2 0]
[0 0 3]]

2.6.单位矩阵

单位矩阵并不是所有元素都为 $1$

代码片段：

import numpy as np
I = np.eye(4)
print(I)

运行结果：

[[ 1. 0. 0. 0.]
[ 0. 1. 0. 0.]
[ 0. 0. 1. 0.]
[ 0. 0. 0. 1.]]

3.矩阵的简单计算：加法与数量乘法

3.1.矩阵的加法

矩阵之间的加法必须运用到相等规模的两个矩阵之间，即：行数和列数相等的两个矩阵之间才能做加法运算。这个非常容易理解，将对应位置上的元素相加即可得到结果矩阵。

$[\begin{matrix} a_{11} & a_{12} & a_{13} \\ a_{21} & a_{22} & a_{23} \end{matrix}] + [\begin{matrix} b_{11} & b_{12} & b_{13} \\ b_{21} & b_{22} & b_{23} \end{matrix}]$

我们还是看看实际的代码：

代码片段：

import numpy as np
A = np.array([[1, 2, 3],
[4, 5, 6]])
B = np.array([[10, 20, 30],
[40, 50, 60]])
print(A+B)

代码片段：

[[11 22 33]
[44 55 66]]

3.2.矩阵的数量乘法

矩阵的数量乘法，描述起来也非常简单：

$c [\begin{matrix} a_{11} & a_{12} & a_{13} \\ a_{21} & a_{22} & a_{23} \end{matrix}] = [\begin{matrix} c a_{11} & c a_{12} & c a_{13} \\ c a_{21} & c a_{22} & c a_{23} \end{matrix}]$

同样，我们看一个代码的例子：

代码片段：

import numpy as np
A = np.array([[1, 2, 3],
[4, 5, 6]])
print(2*A)

运行结果：

[[ 2 4 6]
[ 8 10 12]]

4.矩阵与矩阵的乘法

矩阵与矩阵的相乘，过程要稍微复杂一点。例如下面举例的矩阵 $A$

$[\begin{matrix} a_{11} & a_{12} \\ a_{21} & a_{22} \\ a_{31} & a_{32} \end{matrix}] \times [\begin{matrix} b_{11} & b_{12} & b_{13} \\ b_{21} & b_{22} & b_{23} \end{matrix}] = [\begin{matrix} a_{11} b_{11} + a_{12} b_{21} & a_{11} b_{12} + a_{12} b_{22} & a_{11} b_{13} + a_{12} b_{23} \\ a_{21} b_{11} + a_{22} b_{21} & a_{21} b_{12} + a_{22} b_{22} & a_{21} b_{13} + a_{22} b_{23} \\ a_{31} b_{11} + a_{32} b_{21} & a_{31} b_{12} + a_{32} b_{22} & a_{31} b_{13} + a_{32} b_{23} \end{matrix}]$

仔细观察这个计算公式，我们总结出以下的一些要求和规律：

1 左边矩阵的列数要和右边矩阵的行数相等
2 左边矩阵的行数决定了结果矩阵的行数
3 右边矩阵的列数决定了结果矩阵的列数

同样，我们用python来演示下面这个例子：

$[\begin{matrix} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{matrix}] \times [\begin{matrix} 3 & 4 & 5 \\ 6 & 7 & 8 \end{matrix}]$

代码片段：

import numpy as np
A = np.array([[1, 2],
[3, 4],
[5, 6]])
B = np.array([[3, 4, 5],
[6, 7, 8]])
print(np.dot(A, B))

运行结果：

[[15 18 21]
[33 40 47]
[51 62 73]]

5.矩阵乘以向量，改变向量的空间位置

矩阵与向量的乘法，一般而言写作矩阵 $A$

$[\begin{matrix} a_{11} & a_{12} \\ a_{21} & a_{22} \\ a_{31} & a_{32} \end{matrix}] [\begin{matrix} x_{11} \\ x_{21} \end{matrix}] = [\begin{matrix} a_{11} x_{11} + a_{12} x_{21} \\ a_{21} x_{11} + a_{22} x_{21} \\ a_{31} x_{11} + a_{32} x_{21} \end{matrix}]$

我们对照前面讲过的矩阵与矩阵的乘法，来对比一下矩阵与向量的乘法规则，我们把列向量看作是列数为 $1$

1、矩阵在左，列向量在右，矩阵的列数和列向量的维数必须相等
2、矩阵和向量相乘的结果也是一个向量
3、矩阵的行数就是最终结果输出的列向量的维数
4、乘法的规则如上所示，就是矩阵的每行和列向量进行对应元素分别相乘后相加

我们来看一个矩阵与列向量相乘的例子：

$[\begin{matrix} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{matrix}] [\begin{matrix} 4 \\ 5 \end{matrix}] = [\begin{matrix} 1 \times 4 + 2 \times 5 \\ 3 \times 4 + 4 \times 5 \\ 5 \times 4 + 6 \times 5 \end{matrix}] = [\begin{matrix} 14 \\ 32 \\ 50 \end{matrix}]$

代码片段：

import numpy as np
A = np.array([[1, 2],
[3, 4],
[5, 6]])
x = np.array([[4, 5]]).T
print(np.dot(A, x))

运行结果：

[[14]
[32]
[50]]

从结果看，原始向量表示二维空间中的一个点，坐标为 $(4, 5)$

因此从这个例子中我们可以总结一下矩阵的作用：在特定矩阵的乘法作用下，原空间中的向量坐标，被映射到了目标空间中的新坐标，向量的空间位置（甚至是所在空间维数）由此发生了转化。

============================================================

https://xiaozhuanlan.com/LinearAlgebra/4950187326

张雨萌-酱油哥的《机器学习线性代数核心》

这本书试读了一章，还是值得推荐的，大家可以去在线购买，以上是链接

============================================================