【线性代数】2-4:矩阵操作(Matrix Operations)

title: 【线性代数】2-4:矩阵操作(Matrix Operations)

toc: true

categories:

• Mathematic
• Linear Algebra
  
  date: 2017-09-05 17:15:19
  
  keywords:
• addition
• subtraction
• multiplication
• inner product
• outer product

---

Abstract: 矩阵基本计算，包括加减乘法，主要是乘法的几种不同的理解

Keywords: Addition，Subtraction，Multiplication，Inner Product，Outer Product

开篇废话

今天的废话是，还没想好，想好了再补上

矩阵加法、减法

矩阵加减法，规则很简单，矩阵要求尺寸一样，row一样，column也得一样，这样按照对位相加减就行了。

[a11a12a13a21a22a23a31a32a33]±[b11b12b13b21b22b23b31b32b33]=[a11±a11a12±b12a13±b13a21±b21a22±b22a23±b23a31±b31a32±b32a33±b33]
\begin{bmatrix}a_{11}&&a_{12}&&a_{13}\\
a_{21}&&a_{22}&&a_{23}\\
a_{31}&&a_{32}&&a_{33}\end{bmatrix}
\pm
\begin{bmatrix}b_{11}&&b_{12}&&b_{13}\\
b_{21}&&b_{22}&&b_{23}\\
b_{31}&&b_{32}&&b_{33}\end{bmatrix}\\=
\begin{bmatrix}a_{11}\pm a_{11}&&a_{12}\pm b_{12}&&a_{13}\pm b_{13}\\
a_{21}\pm b_{21}&&a_{22}\pm b_{22}&&a_{23}\pm b_{23}\\
a_{31}\pm b_{31}&&a_{32}\pm b_{32}&&a_{33}\pm b_{33}\end{bmatrix}
⎣⎡​a11​a21​a31​​​a12​a22​a32​​​a13​a23​a33​​⎦⎤​±⎣⎡​b11​b21​b31​​​b12​b22​b32​​​b13​b23​b33​​⎦⎤​=⎣⎡​a11​±a11​a21​±b21​a31​±b31​​​a12​±b12​a22​±b22​a32​±b32​​​a13​±b13​a23​±b23​a33​±b33​​⎦⎤​

这个没啥好说的，别减错地方就行。一对一进行

乘法

乘法才是矩阵计算的关键，计算意义，计算量，等很多是些非常有意义的研究课题，我记得本科学习线性代数的时候，老师先来将行列式，接着就是矩阵的计算法则，然后接着就是rank类的东西了，确实书本是这么讲的，但是现在想想，好像没啥逻辑，所以就没去上课了（给自己随便找个借口逃课）。

矩阵规模

相乘的两个矩阵尺寸上有些要求，例如对于： ABABAB

If A has n column,B must have n rows

如果A为m×nm\times nm×n，B为 n×pn\times pn×p那么他们相乘的结果：

(m×n)(n×p)=(m×p)
(m\times n)(n \times p)=(m\times p)
(m×n)(n×p)=(m×p)

Row Dot Product Column

Dot product之前已经讲过了，就是如何通过两个向量，pia的一下变成一个数字，矩阵可以看做是向量组成的，所以给出第一个规则，假设乘法为AB=CAB=CAB=C

Cij=(row  i  of  A)⋅(column  j  of  B)
C_{ij}=(row\;i\;of\;A) \cdot (column\;j\;of\;B)
Cij​=(rowiofA)⋅(columnjofB)

这个规则是我之前上课学的，也是最基本的矩阵乘法公式，当然也可以写成求和的形式，但是我觉得通过dot product来看这个反而更直观一些，就不再把求和那个写出来了，补充句，在矩阵相乘的编程处理中，经过调整内外层循环，可以最大化利用高速缓冲，能够提高乘法速度。这个让我想起来之前项目，同事非要自己写乘法，然后就按照公式计算顺序，写了一个一毛一样的东西出来，虽然只做3x3的一个小矩阵乘法，速度什么的基本没什么影响，但是我觉得这当你不能保证你写的功能的稳定性和速度的时候，使用稳定的第三方库是个不错的选择。

Inner or Outer

dot product也叫inner product，当时我就在想有没有outer product，Pro. Strang在课堂上没有介绍outer但是在书上写了下，inner的矩阵形式是这样的：

[a1a2…an][b1b2⋮bn]=∑i=0nai∗bi
\begin{bmatrix}a_1&a_2&\dots&a_n\end{bmatrix}
\begin{bmatrix}b_1\\b_2\newline \vdots \\b_n\end{bmatrix}=\sum_{i=0}^{n}a_i*b_i
[a1​​a2​​…​an​​]⎣⎢⎡​b1​b2​⋮bn​​⎦⎥⎤​=i=0∑n​ai​∗bi​

outer的矩阵形式，就是。。

[a1a2⋮an][b1b2…bm]=[a1b1a1b2…a1bma2b1a2b2…a2bm⋮⋮…⋮anb1anb2…anbm]
\begin{bmatrix}a_1\\a_2\newline \vdots \\a_n\end{bmatrix}
\begin{bmatrix}b_1&b_2&\dots&b_m\end{bmatrix}
=\begin{bmatrix}
a_1b_1&&a_1b_2&&\dots &&a_1b_m\\
a_2b_1&&a_2b_2&&\dots &&a_2b_m\\
\vdots&&\vdots&&\dots &&\vdots\\
a_nb_1&&a_nb_2&&\dots &&a_nb_m\\
\end{bmatrix}
⎣⎢⎡​a1​a2​⋮an​​⎦⎥⎤​[b1​​b2​​…​bm​​]=⎣⎢⎢⎢⎡​a1​b1​a2​b1​⋮an​b1​​​a1​b2​a2​b2​⋮an​b2​​​…………​​a1​bm​a2​bm​⋮an​bm​​⎦⎥⎥⎥⎤​

其实outer的过程通过一行一列产生一个矩阵，所以当多列和多行（行和列必须相等数量）的矩阵相乘的时候就会产生多个矩阵，再对矩阵进行相加，这个过程的编程实现时，缓存利用率很高，就是本段开头说道的矩阵相乘的速度问题，当然这是不是最快的解决办法我也不知道，知识从哪本书上看到了这种说法，印象比较深刻

Column Model

列模型，如果把矩阵看做是很多列的组合，那么可以回归到最早的Ax=bAx=bAx=b的过程

AAA是被乘矩阵, x\textbf{x}x 扩展成多列的矩阵XXX

X=[⋮⋮…⋮x1x2…xn⋮⋮…⋮]
X=\begin{bmatrix}
\vdots&&\vdots&&\dots &&\vdots\\
x_1&&x_2&&\dots&&x_n\\
\vdots&&\vdots&&\dots &&\vdots\\
\end{bmatrix}
X=⎣⎢⎢⎡​⋮x1​⋮​​⋮x2​⋮​​………​​⋮xn​⋮​⎦⎥⎥⎤​

把x代入

$$

AX=

A

\begin{bmatrix}

\vdots&&\vdots&&\dots &&\vdots\

x_1&&x_2&&\dots&&x_n\

\vdots&&\vdots&&\dots &&\vdots\

\end{bmatrix}\

\begin{bmatrix}

\vdots&&\vdots&&\dots &&\vdots\

A x_1&&A x_2&&\dots&&A x_n\

\vdots&&\vdots&&\dots &&\vdots\

\end{bmatrix}

$$

写数学类的博客就是累，还是贴代码那种技术博客好写。

把X分解成多个列，每列与A的乘积作为结果对应的列，这就是列视角，或者叫做列模型

Row Model

有行就有列，有列就有行：

$$

A=\begin{bmatrix}

\dots&& a_1 &&\dots\

\dots&& a_2 &&\dots\

\vdots&&\vdots&&\vdots\

\dots&& a_m &&\dots\

\end{bmatrix}\

AX=

\begin{bmatrix}

\dots&& a_1 &&\dots\

\dots&& a_2 &&\dots\

\vdots&&\vdots&&\vdots\

\dots&& a_m &&\dots\

\end{bmatrix}X

\begin{bmatrix}

\dots&& a_1X &&\dots\

\dots&& a_2X &&\dots\

\vdots&&\vdots&&\vdots\

\dots&& a_mX &&\dots\

\end{bmatrix}

$$

行过程和列过程基本呈现一种对称关系，这也是线性代数有趣的一点，经常是左右开工，得到相同的结果。

Block

没错，矩阵是可以切块的，最极端的方式就是每个矩阵按照一个块一个元素的切法，那就和原始矩阵一样了，这种切块粒度太小，如果把一个矩阵当做一块，那粒度又太大，举个一般的例子