標量、向量、矩陣、張量之間的區別和聯系

前言

深度學習的表現之所以能夠超過傳統的機器學習演算法離不開神經網路，然而神經網路最基本的資料結構就是向量和矩陣，神經網路的輸入是向量，然后通過每個矩陣對向量進行線性變換，再經過激活函式的非線性變換，通過層層計算最終使得損失函式的最小化，完成模型的訓練，所以要想學好深度學習，對這些基礎的資料結構還是要非常了解，

標量

標量(scalar)：一個標量就是一個單獨的數(整數或實數)，不同于線性代數中研究的其他大部分物件(通常是多個數的陣列)，標量通常用斜體的小寫字母來表示，例如： x \mathit x x，標量就相當于Python中定義的

x = 1

向量

向量(vector)：一個向量表示一組有序排列的數，通過次序中的索引我們能夠找到每個單獨的數，向量通常用粗體的小寫字母表示，例如： x \bf x x，向量中的每個元素就是一個標量，向量中的第 i i i個元素用 x i x_i xi?表示，向量相當于Python中的一維陣列

import numpy as np
#行向量
a = np.array([1,2,3,4])

矩陣

矩陣(matrix)：矩陣是一個二維陣列，其中的每一個元素由兩個索引來決定( A i , j A_{i,j} Ai,j?)，矩陣通常用加粗斜體的大寫字母表示，例如： X \boldsymbol X X，我們可以將矩陣看做是一個二維的資料表，矩陣的每一行表示一個物件，每一串列示一個特征，在Python中的定義為

import numpy as np
#矩陣
a = np.array([[1,2,3],[4,5,6],[7,8,9]])

張量

張量(tensor)：超過二維的陣列，一般來說，一個陣列中的元素分布在若干維坐標的規則網格中，被稱為張量，如果一個張量是三維陣列，那么我們就需要三個索引來決定元素的位置( A i , j , k A_{i,j,k} Ai,j,k?)，張量通常用加粗的大寫字母表示，例如： X \bf X X

import numpy as np
#張量
a = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])

標量向量矩陣張量之間的聯系

通過上面的介紹可以總結一下，標量是0維空間中的一個點，向量是一維空間中的一條線，矩陣是二維空間的一個面，三維張量是三維空間中的一個體，也就是說，向量是由標量組成的，矩陣是向量組成的，張量是矩陣組成的，

用一個比較通俗的例子可以概括為：假設你手中拿著一根棍子，標量就是我們只知道棍子的長度，但是不知道棍子指向的方向，向量就是我們除了知道棍子的長度之外還知道棍子指向的是左邊還是右邊，矩陣就是除了知道向量知道的資訊外還知道棍子是朝上還是朝下，張量就是除了知道矩陣知道的資訊外還知道棍子是朝前還是朝后，

線性代數常用的運算

一、向量的運算

1.點積

點積(dot product)又被稱為數量積(scalar product)或者內積(inner product)：是指接受在實數R上的兩個向量并回傳一個實數值標量的二元運算，

代數意義

兩個向量 a ( a 1 , a 2 , … , a n ) a (a_1, a_2,…, a_n) a(a1?,a2?,…,an?)和 b ( b 1 , b 2 , … , b n ) b(b_1, b_2,…, b_n) b(b1?,b2?,…,bn?)的點積定義為： a ? b = a 1 b 1 + a 2 b 2 + … … + a n b n a·b=a_1b_1+a_2b_2+……+a_nb_n a?b=a1?b1?+a2?b2?+……+an?bn?，使用矩陣乘法并把（縱列）向量當作n×1 矩陣，點積還可以寫為： a ? b = a T ? b a·b=a^T * b a?b=aT?b，這里的 a T a^T aT指示矩陣 a a a的轉置，

import numpy as np
a = np.array([1,2,3])
b = np.array([3,2,1])
#向量的點積運算
print(np.dot(a,b))#10

幾何意義

除此之外，向量積還有另一種定義 a ? ? b ? = ∣ a ? ∣ ? ∣ b ? ∣ ? c o s θ \vec a·\vec b=|\vec a|*|\vec b| * cos\theta a ?b =∣a ∣?∣b ∣?cosθ，該定義只對二維和三維空間有效， ∣ a ? ∣ |\vec a| ∣a ∣和 ∣ b ? ∣ |\vec b| ∣b ∣表示向量的長度， θ \theta θ表示向量之間的夾角，

這個運算可以簡單地理解為：在點積運算中，第一個向量投影到第二個向量上（這里，向量的順序是不重要的，點積運算是可交換的），然后通過除以它們的標量長度來“標準化”，這樣，這個分數一定是小于等于1的，可以簡單地轉化成一個角度值，利用向量積的幾何意義，我們可以用來計算兩個向量之間的夾角，

2.外積

設向量 c ? \vec c c 由兩個向量 a ? \vec a a 與 b ? \vec b b 按下列方式定出： c ? \vec c c 的模 ∣ c ∣ = ∣ a ∣ ∣ b ∣ s i n < a , b > |c|=|a||b|sin<a,b> ∣c∣=∣a∣∣b∣sin<a,b> c ? \vec c c 的方向垂直于 a ? \vec a a 與 b ? \vec b b 所決定的平面（即 c ? \vec c c 既垂直于 a ? \vec a a ，又垂直于 b ? \vec b b ）， c ? \vec c c 的指向按右手規則從 a ? \vec a a 轉向 b ? \vec b b 來確定，

那么，向量 c ? \vec c c 叫做向量 a ? \vec a a 與 b ? \vec b b 的外積，記作 a ? × b ? \vec a×\vec b a ×b ，即 c ? = a ? × b ? \vec c=\vec a×\vec b c =a ×b ， ∣ a ? × b ? ∣ |\vec a×\vec b| ∣a ×b ∣的值與以 a ? \vec a a ， b ? \vec b b 為鄰邊的平行四邊形的面積的值相同，一般地，向量外積的研究僅限于三維空間中

import numpy as np

a = np.array([0,2])
b = np.array([3,3])
#向量的外積
c = np.cross(b,a)
print(c)

通過外積我們可以用來快速求解平行四邊形或三角形的面積，需要注意的是在計算向量積時候，向量之間的順序，順序相反會得到相反的結果(正數和負數)，判斷方向時采用右手定則，

3.向量的范數

定義一個向量， x = [ x 1 , x 2 , . . . x n ] x=[x_1,x_2,...x_n] x=[x1?,x2?,...xn?]

• 向量的1范數：向量中各個元素絕對值之和， ∣ ∣ x ∣ ∣ 1 = ∑ i = 1 N ∣ x i ∣ ||x||_1=\sum_{i=1}^{N}|x_i| ∣∣x∣∣1?=∑i=1N?∣xi?∣
• 向量的2范數：向量中每個元素的平方和的平方根， ∣ ∣ x ∣ ∣ 2 = ∑ i = 1 N x i 2 ||x||_2=\sqrt{\sum_{i=1}^{N}x_i^2} ∣∣x∣∣2?=∑i=1N?xi2? ?
• 向量的負無窮范數：向量中所有元素的絕對值中最小的， ∣ ∣ x ∣ ∣ ? ∞ = m i n 1 ≤ x ≤ N ∣ x i ∣ ||x||_{-\infty}=\underset {1 \leq x \leq N}{min}|x_i| ∣∣x∣∣?∞?=1≤x≤Nmin?∣xi?∣
• 向量的正無窮范數：向量中所有元素的絕對值中最大的， ∣ ∣ x ∣ ∣ ∞ = m a x 1 ≤ x ≤ N ∣ x i ∣ ||x||_{\infty}=\underset {1 \leq x \leq N}{max}{|x_i|} ∣∣x∣∣∞?=1≤x≤Nmax?∣xi?∣
• 向量的 p p p范數：向量中每個元素的 p p p次方和的 1 / p 1/p 1/p次冪， ∣ ∣ x ∣ ∣ p = ( ∑ i = 1 N ∣ x ∣ p ) 1 / p ||x||_p=(\sum_{i=1}^{N}|x|^p)^{1/p} ∣∣x∣∣p?=(∑i=1N?∣x∣p)1/p

二、矩陣的運算

1 .轉置

轉置(transpose)：是矩陣的重要操作之一，矩陣的轉置是以對角線為軸的鏡像，這條從左上角到右下角的對角線被稱為主對角線(main diagonal)，如下圖所示

其實就是將原矩陣的行變成了轉置矩陣的列或將原矩陣的列變成轉置矩陣的行，

2.矩陣的范數

定義一個矩陣 A m n = { a 11 a 12 ? a 1 n a 21 a 22 ? a 2 n ? ? ? ? a m 1 a m 2 ? a m n } \boldsymbol A_{mn}= \left\{ \begin{matrix} a_{11}& a_{12} & \cdots & a_{1n}\\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \end{matrix} \right\} Amn?=??????????a11?a21??am1??a12?a22??am2???????a1n?a2n??amn????????????

• 矩陣的1范數(列范數)：對矩陣每一列上的元素絕對值求和，再從中取一個列和最大的值， ∣ ∣ A ∣ ∣ 1 = m a x 1 ≤ j ≤ n ∑ i = 1 m ∣ a i j ∣ ||\boldsymbol A||_1=\underset {1 \leq j \leq n}{max} \sum_{i=1}^{m}|a_{ij}| ∣∣A∣∣1?=1≤j≤nmax?∑i=1m?∣aij?∣
• 矩陣的2范數：矩陣 A T A \boldsymbol A^T \boldsymbol A ATA的最大特征值的平方根， ∣ ∣ A ∣ ∣ 2 = λ m a x ( A T A ) ||\boldsymbol A||_2 = \sqrt{\lambda_{max}(\boldsymbol A^T \boldsymbol A)} ∣∣A∣∣2?=λmax?(ATA) ?，式中的 λ m a x ( A T A ) \lambda_{max}(\boldsymbol A^T \boldsymbol A) λmax?(ATA)為 A T A \boldsymbol A^T \boldsymbol A ATA的特征值絕對值最大的值，關于矩陣的特征值介紹將會在下一篇文章中詳細介紹
• 矩陣的無窮范數(行范數)：對矩陣每一行的元素絕對值求和，再從中取一個行和最大的值， ∣ ∣ A ∣ ∣ ∞ = m a x 1 ≤ i ≤ m ∑ j = 1 n ∣ a i j ∣ ||\boldsymbol A||_\infty=\underset {1 \leq i \leq m}{max} \sum_{j=1}^{n}|a_{ij}| ∣∣A∣∣∞?=1≤i≤mmax?∑j=1n?∣aij?∣
• 矩陣的核范數：矩陣的奇異值之和，這個范數可以用低秩表示
• 矩陣的 L 0 L_0 L0?范數：矩陣的非0元素的個數，通常用它來表示稀疏度， L 0 L_0 L0?范數越小，0元素越多，矩陣就越稀疏，
• 矩陣的 L 1 L_1 L1?范數：矩陣中的每個元素的絕對值之和，它是 L 0 L_0 L0?范數的最優凸近似，
• 矩陣的 F F F范數：矩陣的各個元素的平方之和再開平方根，通常也稱為矩陣的 L 2 L_2 L2?范數，
• 矩陣的 L 21 L_{21} L21?范數：矩陣先以每一列為單位，求每一列的 L 2 L_2 L2?范數，再將得到的結果求 L 1 L_1 L1?范數，所以它是介于 L 1 L_1 L1?和 L 2 L_2 L2?之間的一種范數，

3.常見的矩陣

• 方陣：也就方形矩陣，矩陣的列數與行數相等
• 對稱矩陣：對稱矩陣是一個方陣，矩陣的元素關于對角線對稱，它的轉置和自身相等，即 A = A T A=A^T A=AT
• Jacobian矩陣：Jacobian矩陣是函式的一階偏導數以一定方式排列成的矩陣
• 單位矩陣：主對角線上的元素都為1，其余元素全為0的n階矩陣稱為n階單位矩陣，記為 I n I_n In?或 E n E_n En? ，通常用 I I I或 E E E來表示
• 正交矩陣：如果 A A T = I n AA^T=I_n AAT=In?，則 A A A就被稱為正交矩陣

4.矩陣的乘法

矩陣乘法：是最常見的矩陣乘積，兩個矩陣相乘，必須要滿足前一個矩陣的列數等于后一個矩陣的行數，一個 m × p m×p m×p的矩陣乘以一個 p × n p×n p×n會得到一個 m × n m×n m×n的矩陣，運算規則如下

numpy的實作如下，和向量積一樣

import numpy as np

a = np.array([[1,2,3],
              [-1,3,-2]])
b = np.array([[1,2],
              [3,4],
              [1,3]])
#矩陣相乘
print(np.dot(a,b))#或者使用np.matmul(a,b)
"""
[[10 19]
 [ 6  4]]
"""

5.矩陣哈達馬積

哈達馬積（Hadamard product）：也叫矩陣的元素相乘，矩陣對應元素相乘，兩個矩陣在進行元素相乘的時候必須要有相同的行數和列數，計算公式如下

在Python中計算兩個矩陣元素相乘的乘積直接相乘即可，如果兩個相乘的矩陣行數和列數不相等會報錯，相乘的時候其中一個可以是標量或向量，會自動使用廣播，標量乘以矩陣中的所有元素，相當于對矩陣的元素做一個縮放

import numpy as np

a = np.array([[1,2],[3,4]])
b = np.array([[2,2],[1,3]])
#矩陣的元素相乘
c = a * b
print(c)
"""
[[ 2  4]
 [ 3 12]]
"""
#矩陣的廣播
d = a * 2
print(d)
"""
[[2 4]
 [6 8]]
"""
d = a * np.array([1,2])
print(d)
"""
[[1 4]
 [3 8]]
"""

6.克羅內克積

克羅內克積（Kronecker Product）：克羅內克積是兩個任意大小的矩陣間的運算，符號記作 ? \otimes ? ，克羅內克積也被稱為直積或張量積，計算程序如下例所示：