[AI 笔记] Numpy

参考资料：

CS231n课程笔记翻译：Python Numpy教程

数组arrays

每个Numpy数组都是数据类型相同的元素组成的网格

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(type(a))
print(a.shape)          
print(a)
print(a[0])
print(a[1,1])

<class 'numpy.ndarray'>
(2, 3)
[[1 2 3]
 [4 5 6]]
[1 2 3]
5

创建数组方法

import numpy as np

a = np.zeros((2,2))      #全零数组
print(a)

b = np.ones((2,2))       #全1数组
print(b)

c = np.full((2,2), 7)    #全指定常数数组
print(c)

d = np.eye(2)            #指定维度单位矩阵
print(d)

e = np.random.random((2,2))  #随机数组
print(e)

[[0. 0.]
 [0. 0.]]
[[1. 1.]
 [1. 1.]]
[[7 7]
 [7 7]]
[[1. 0.]
 [0. 1.]]
[[0.74992187 0.36602064]
 [0.33322249 0.95573549]]

访问数组

import numpy as np

a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
b = a[:2, 1:3]        #切片操作
print(a)
print(b)

print(a[0, 1])
b[0,0] = 55            #共享内存
print(a[0, 1])
a[0, 1] = 2

row1 = a[0, :]         #第一行
row2 = a[0:1, :]       #体会不同
print(row1)
print(row2)

column1 = a[:, 1]      #第二列
column2 = a[:, 1:2]    #体会不同
print(column1)
print(column2)

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
[[2 3]
 [6 7]]
2
55
[1 2 3 4]
[[1 2 3 4]]
[ 2  6 10]
[[ 2]
 [ 6]
 [10]]

整型数组访问

import numpy as np

a = np.array([[1,2], [3, 4], [5, 6]])
print(a[[0, 1, 2], [0, 1, 0]])                 #对应位置组成索引
print(np.array([a[0, 0], a[1, 1], a[2, 0]]))   #两者等效

[1 4 5]
[1 4 5]

布尔型数组访问

import numpy as np

a = np.array([[1,2], [3, 4], [5, 6]])

bool_idx = (a > 2)
print(bool_idx)

print(a[bool_idx])

print(a[a > 2])

[[False False]
 [ True  True]
 [ True  True]]
[3 4 5 6]
[3 4 5 6]

数据类型

import numpy as np

x = np.array([1, 2])  
print(x.dtype)         #int64

x = np.array([1.0, 2.0])  
print(x.dtype)             #float64

x = np.array([1, 2], dtype=np.float64)  #指定数据类型
print(x.dtype) 

int32
float64
float64

数组计算

基本数学计算函数会对数组中元素逐个进行计算，既可以利用操作符重载，也可以使用函数方式

import numpy as np

x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)

print(x + y)
print(np.add(x, y))

print(x - y)
print(np.subtract(x, y))

print(x * y)
print(np.multiply(x, y))

print(x / y)
print(np.divide(x, y))

print(np.sqrt(x))

[[ 6.  8.]
 [10. 12.]]
[[ 6.  8.]
 [10. 12.]]
[[-4. -4.]
 [-4. -4.]]
[[-4. -4.]
 [-4. -4.]]
[[ 5. 12.]
 [21. 32.]]
[[ 5. 12.]
 [21. 32.]]
[[0.2        0.33333333]
 [0.42857143 0.5       ]]
[[0.2        0.33333333]
 [0.42857143 0.5       ]]
[[1.         1.41421356]
 [1.73205081 2.        ]]

和MATLAB不同，*是元素逐个相乘，而不是矩阵乘法。在Numpy中使用dot来进行矩阵乘法

import numpy as np

x = np.array([[1,2],[3,4]])
y = np.array([[5,6],[7,8]])

v = np.array([9,10])
w = np.array([11, 12])

print (v.dot(w))
print (np.dot(v, w))

print (x.dot(v))
print (np.dot(x, v))

print (x.dot(y))                 #后面的需要转置过来
print (np.dot(x, y))

219
219
[29 67]
[29 67]
[[19 22]
 [43 50]]
[[19 22]
 [43 50]]

sum函数

import numpy as np

x = np.array([[1,2],[3,4]])

print (np.sum(x))  #计算所有元素的和
print (np.sum(x, axis=0))  #计算每一列的和
print (np.sum(x, axis=1))  #计算每一行的和

10
[4 6]
[3 7]

T转置

import numpy as np

x = np.array([[1,2], [3,4]])
print (x)          
print (x.T) 
           
v = np.array([1,2,3])     #一维数组的转置不变
print (v)    
print (v.T) 

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

广播Broadcasting

广播是一种强有力的机制，它让Numpy可以让不同大小的矩阵在一起进行数学计算。我们常常会有一个小的矩阵和一个大的矩阵，然后我们会需要用小的矩阵对大的矩阵做一些计算。

举个例子，如果我们想要把一个向量加到矩阵的每一行，我们可以这样做：

import numpy as np

x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = np.empty_like(x)   #和x形状一样的空数组

for i in range(4):              #循环相加
    y[i, :] = x[i, :] + v

print (y)

[[ 2  2  4]
 [ 5  5  7]
 [ 8  8 10]
 [11 11 13]]

这样是行得通的，但是当x矩阵非常大，利用循环来计算就会变得很慢很慢。我们可以换一种思路：

import numpy as np

x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
vv = np.tile(v, (4, 1))   #复制4份v  
print (vv)

y = x + vv 
print (y) 

[[1 0 1]
 [1 0 1]
 [1 0 1]
 [1 0 1]]
[[ 2  2  4]
 [ 5  5  7]
 [ 8  8 10]
 [11 11 13]]

Numpy广播机制可以让我们不用创建vv，就能直接运算，看看下面例子：

import numpy as np

x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = x + v  #直接相加
print (y)

[[ 2  2  4]
 [ 5  5  7]
 [ 8  8 10]
 [11 11 13]]

对两个数组使用广播机制要遵守下列规则：

1.如果数组的秩不同，使用1来将秩较小的数组进行扩展，直到两个数组的尺寸的长度都一样。
2.如果两个数组在某个维度上的长度是一样的，或者其中一个数组在该维度上长度为1，那么我们就说这两个数组在该维度上是相容的。
3.如果两个数组在所有维度上都是相容的，他们就能使用广播。
4.如果两个输入数组的尺寸不同，那么注意其中较大的那个尺寸。因为广播之后，两个数组的尺寸将和那个较大的尺寸一样。
5.在任何一个维度上，如果一个数组的长度为1，另一个数组长度大于1，那么在该维度上，就好像是对第一个数组进行了复制。