一、Python的矩陣傳播機制（Broadcasting）

我們知道在深度學習中經常要操作各種矩陣（matrix）。

回想一下，我們在操作數組（list）的時候，經常習慣于用**for循環（for-loop）**來對數組的每一個元素進行操作。例如：

my_list = ［1，2，3，4］

new_list = ［］

for each in my_list：

new_list.append（each*2）

print（new_list） # 輸出 ［2，3，4，5］

如果是矩陣呢：

my_matrix = ［［1，2，3，4］，

［5，6，7，8］］

new_matrix = ［［］，［］］

for i in range（2）：

for j in range（4）：

new_matrix［i］.append（my_matrix［i］［j］*2）

print（new_matrix）# 輸出 ［［2， 4， 6， 8］， ［10， 12， 14， 16］］

實際上，上面的做法是十分的低效的！數據量小的話還不明顯，如果數據量大了，尤其是深度學習中我們處理的矩陣往往巨大，那用for循環去跑一個矩陣，可能要你幾個小時甚至幾天。

Python考慮到了這一點，這也是本文主要想介紹的**“Python的broadcasting”即傳播機制**。

先說一句，python中定義矩陣、處理矩陣，我們一般都用numpy這個庫。

二、下面展示什么是python的傳播機制

import numpy as np# 先定義一個3×3矩陣 A：

A = np.array（

［［1，2，3］，

［4，5，6］，

［7，8，9］］）

print（“A：

”，A）

print（“

A*2：

”，A*2） # 直接用A乘以2print（“

A+10：

”，A+10） # 直接用A加上10

運行結果：

A：

［［1 2 3］

［4 5 6］

［7 8 9］］

A*2：

［［ 2 4 6］

［ 8 10 12］

［14 16 18］］

A+10：

［［11 12 13］

［14 15 16］

［17 18 19］］

接著，再看看矩陣×（+）矩陣：

#定義一個3×1矩陣（此時也可叫向量了）

B = np.array（［［10］，

［100］，

［1000］］）

print（“

B：

”，B）

print（“

A+B：

”，A+B）

print（“

A*B：

”，A*B）

運行結果：

B：

［［ 10］

［ 100］

［1000］］

A+B：

［［ 11 12 13］

［ 104 105 106］

［1007 1008 1009］］

A*B：

［［ 10 20 30］

［ 400 500 600］

［7000 8000 9000］］

可見，雖然A和B的形狀不一樣，一個是3×3，一個是3×1，但是我們在python中可以直接相加、相乘，相減相除也可以。

也許看到這，大家都對broadcasting有感覺了。

用一個圖來示意一下：

所謂“傳播”，就是把一個數或者一個向量進行“復制”，從而作用到矩陣的每一個元素上。

有了這種機制，那進行向量和矩陣的運算，就太方便了！理解了傳播機制，就可以隨心所欲地對矩陣進行各種便捷的操作了。

利用numpy的內置函數對矩陣進行操作：

numpy內置了很多的數學函數，例如np.log（），np.abs（），np.maximum（）等等上百種。直接把矩陣丟進去，就可以算出新矩陣！示例：

print（np.log（A））

輸出把A矩陣每一個元素求log后得到的新矩陣：

array（［［0. ， 0.69314718， 1.09861229］，

［1.38629436， 1.60943791， 1.79175947］，

［1.94591015， 2.07944154， 2.19722458］］）

再比如深度學習中常用的ReLU激活函數，就是y=max（0，x），

也可以對矩陣直接運算：

X = np.array（［［1，-2，3，-4］， ［-9，4，5，6］］）Y = np.maximum（0，X）print（Y）

得到：

［［1 0 3 0］ ［0 4 5 6］］

更多的numpy數學函數，可以參見文檔：https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.math.html

三、定義自己的函數來處理矩陣

其實這才是我寫下本文的目的。。。前面扯了這么多，只是做個鋪墊（/ω＼）

我昨天遇到個問題，就是我要對ReLU函數求導，易知，y=max（0，x）的導函數是：y’ = 0 if x《0y’ = 1 if x》0但是這個y’（x）numpy里面沒有定義，需要自己構建。即，我需要將矩陣X中的小于0的元素變為0，大于0的元素變為1。搞了好久沒弄出來，后來在StackOverflow上看到了解決辦法：

def relu_derivative（x）：

x［x《0］ = 0

x［x》0］ = 1

return x

X = np.array（［［1，-2，3，-4］，

［-9，4，5，6］］）

print（relu_derivative（X））

輸出：

［［1 0 1 0］

［0 1 1 1］］

**居然這么簡潔就出來了！！！**ミ?Д?彡 （?Д?#）

這個函數relu_derivative中最難以理解的地方，就是**x［x》0］**了。于是我試了一下：

X = np.array（［［1，-2，3，-4］，

［-9，4，5，6］］）

print（X［X》0］）

print（X［X《0］）

輸出：

［1 3 4 5 6］

［-2 -4 -9］

它直接把矩陣X中滿足條件的元素取了出來！原來python對矩陣還有這種操作！

震驚了我好久~

所以可以這么理解，X［X》0］相當于一個“選擇器”，把滿足條件的元素選出來，然后直接全部賦值。

用這種方法，我們便可以定義各種各樣我們需要的函數，然后對矩陣整體進行更新操作了！

四、綜上

可以看出，python以及numpy對矩陣的操作簡直神乎其神，方便快捷又實惠。其實上面忘了寫一點，那就是計算機進行矩陣運算的效率要遠遠高于用for-loop來運算，

不信可以用跑一跑：

# vetorization vs for loop# define two arrays a， b：

a = np.random.rand（1000000）

b = np.random.rand（1000000）

# for loop version：

t1 = time.time（）

c = 0

for i in range（1000000）：

c += a［i］*b［i］

t2 = time.time（）

print（c）

print（“for loop version：”+str（1000*（t2-t1））+“ms”）

time1 = 1000*（t2-t1）

# vectorization version：

t1 = time.time（）

c = np.dot（a，b）

t2 = time.time（）

print（c）

print（“vectorization version：”+str（1000*（t2-t1））+“ms”）

time2 = 1000*（t2-t1）

print（“vectorization is faster than for loop by ”+str（time1/time2）+“ times！”）

運行結果：

249765.8415288075

for loop version:627.4442672729492ms

249765.84152880745

vectorization version:1.5032291412353516ms

vectorization is faster than for loop by 417.39762093576525 times！

可見，用for方法和向量化方法，計算結果是一樣，但是后者比前者快了400多倍！

因此，在計算量很大的時候，我們要盡可能想辦法對數據進行Vectorizing，即“向量化”，以便讓計算機進行矩陣運算。

責任編輯：haq