前言

很明顯這是接著（一）的續集，這是numpy的基礎學習。上一篇主要說了numpy的創造和合並，以及numpy陣列的合併和分解。主要是說比array.array差不多，但是array沒有那麼多複雜的功能。numpy.array 有這個。這裡說的是矩陣一些通用功能

Universal Function

把陣列當作矩陣或者向量進行計算叫做Universal Function。這裡會把陣列中所有的元素進行計算。

X=np.arange(1,16).reshape(3,5)
X

array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10],
       [11, 12, 13, 14, 15]]
 
)

除法

X/2

array([[ 0.5,  1. ,  1.5,  2. ,  2.5],
       [ 3. ,  3.5,  4. ,  4.5,  5. ],
       [ 5.5,  6. ,  6.5,  7. ,  7.5]])

取整除法

X//2

array([[0, 1, 1, 2, 2],
       [3, 3, 4, 4, 5],
       [5, 6, 6, 7, 7]])

冪運算

X ** 2

array([[  1,   4,   9,  16,  25],
       [ 36,  49,  64,  81, 100],
       [121, 144, 169, 196, 225]]
 
)

取餘

X % 2
array([[1, 0, 1, 0, 1],
       [0, 1, 0, 1, 0],
       [1, 0, 1, 0, 1]])

等等

np.abs(X)
np.sin(X)
np.exp(X
np.power(X,2)
np.log(X)
np.log2(X)
np.lig10(X)

矩陣間的運算

矩陣之間的運算無非就是矩陣的+ ，-，*，／

A=np.arange(4).reshape(2,2)
A
array([[0, 1],
       [2, 3]])


B=np.full((2,2),fill_value=10)
B 
array([[10, 10],
       [10, 10]]
 
)

這裡無論是加減乘除都是相對應元素上的加減乘除。

A+B
array([[10, 11],
       [12, 13]])
A-B
A*B
A/B 

如果要真正做矩陣的乘法的話，維度一定要對應起來。

A.dot(B)
array([[ 0, 10],
       [20, 30]])

不光可以求兩個矩陣的計算。
還可以求矩陣的轉置和矩陣的逆

求轉置

A.T
array([[0, 2],
       [1, 3]])

求矩陣的逆

這個就比較麻煩，因為我們學過矩陣知道，方陣才有逆。

invA=np.linalg.inv(A)
intvA

array([[-1.5,  0.5],
       [ 1. ,  0. ]])

如果矩陣不是 方陣可以求偽逆

X=np.arange(16).reshape([2,8])
array([[ 0,  1,  2,  3,  4,  5,  6,  7],
       [ 8,  9, 10, 11, 12, 13, 14, 15]])
invX=np.linalg.pinv(X)
invX

array([[ -1.35416667e-01,   5.20833333e-02],
       [ -1.01190476e-01,   4.16666667e-02],
       [ -6.69642857e-02,   3.12500000e-02],
       [ -3.27380952e-02,   2.08333333e-02],
       [  1.48809524e-03,   1.04166667e-02],
       [  3.57142857e-02,  -1.04083409e-17],
       [  6.99404762e-02,  -1.04166667e-02],
       [  1.04166667e-01,  -2.08333333e-02]])

向量與矩陣之間的運算

這是機器學習中常見的運算。
這裡值得一說的是一個一維向量就是一個numpy的array，但是我們學過的向量也分行向量 、列向量。其實numpy可以自己判斷！
首先看看一些“奇怪”的設計。

向量與矩陣的減法

這個怎麼可能呢？違背常理，線性代數中只有兩個矩陣維度相同才能做這樣的操作不是麼？

v=np.array([1,2])
v

array([1, 2])

A=np.arange(4).reshape(2,2)
A

array([[0, 1],
       [2, 3]])

v+A
array([[1, 3],
       [3, 5]])

我們發現numpy中向量與矩陣的加法就是矩陣的每一行的每個元素加上這個向量的每個元素。
相當於

np.vstack([v]*A.shape[0])+A

array([[1, 3],
       [3, 5]])

其實向量的堆疊不需要使用vstack 可以用專門的函式tile
它可以把向量看成一個單元，然後進行單元堆疊

np.tile(v,(2,1)) #行上堆疊兩次，列上一次
array([[1, 2],
       [1, 2]])

np.tile(v,(2,2))
array([[1, 2, 1, 2],
       [1, 2, 1, 2]])

向量與矩陣的乘法

numpy可以自動判斷向量是行向量還是列向量體現在矩陣的乘法。
看

v.dot(A) # E行*列，矩陣乘法
array([4, 7])

這裡就當成了一個行向量。

A.dot(v)
array([2, 8])

這裡就成了列向量。神奇！