一、Numpy介绍、为什么要用Numpy

1、Numpy介绍

Numpy是Python的一个扩展包，语法和Matlab有很多相似之处。它支持高维数组和矩阵运算，也提供了许多数组和矩阵运算的函数。另外，它在数组和矩阵运算方面速度很快，效率很高。

2、为什么要用Numpy

Numpy向量化计算与非向量化计算性能比较

# coding: utf-8

import time

import numpy as np

# Numpy向量化测试

a = np.random.rand(1000000)

b = np.random.rand(1000000)

tic = time.time()

c = np.dot(a,b)

toc = time.time()

print("计算结果"+str(c))

print("向量化使用时间:"+str(1000*(toc-tic)) + "ms")

# 使用for循环测试

c = 0

tic = time.time()

for i in range(1000000):

    c += a[i] * b[i]

toc = time.time()

print("计算结果"+str(c))

print("循环使用时间:"+str(1000*(toc-tic)) + "ms")

#计算结果250011.92519533934

#向量化使用时间:0.9119510650634766ms

#计算结果250011.92519534056

#循环使用时间:466.2208557128906ms

为什么向量化比循环快？

因为Numpy对向量计算做了优化，用到了CPU或GPU的并行计算，所以速度要比单纯的for循环要快。具体细节感兴趣可以自行研究。

二、数组创建

1、生成数组

(1)一维数组

import numpy as np

x = np.array([1.0,2.0,3.0])

print(x)

# [1. 2. 3.]

x = np.np.arange(0,5)

print(x)

# [0 1 2 3 4]

各个元素与标量之间进行运算，称为广播。

(2)二维数组



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

A.shape

# 返回n*m的数组

A.dtype

# 返回数据类型

A.size

# 返回数组元素个数4

np.ndim(A)

#返回数组维数

3、访问元素



for row in A:

  print(row)

A[0]

A[0][1]

A.flatten() #将X转换为一维数组

# [1 2 3 4]

A[np.array([0,1])]#获取索引为1、2的元素

#[[1 2]

#[3 4]]

A > 15 #获得布尔型数组

#[[False False]

# [False False]]

三、矩阵

1、创建矩阵



A = np.matrix('1,2;3,4')

print(A)

print(type((A)))

#[[1 2]

# [3 4]]

#<class 'numpy.matrixlib.defmatrix.matrix'>

2、数组转矩阵



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

#[[1 2]

# [3 4]]

B = np.mat(A)

print(B)

print(type(B))

#<class 'numpy.matrixlib.defmatrix.matrix'>

3、创建单位矩阵



E = np.eye(3)

#[[1. 0. 0.]

# [0. 1. 0.]

# [0. 0. 1.]]

4、改变数组形状



# 将2*2的数组变形为4*1的数组

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

A = A.reshape((A.size,1))

print(A)

#[[1]

 #[2]

 #[3]

 #[4]]

四、计算

1、广播

为何叫广播,因为单个标量被广播、复制成n维数组。

如二维数组[[1,2],[3,4]]与标量10相乘，等同于[[1,2],[3,4]]乘以[[10,10],[10,10]]。

2、矩阵转置

因为np.random.randn(5)写法不直观，建议使用写法np.random.randn(5,1)。

a = np.random.randn(5,1)

#转置

b = a.T

print(a)

#[[-0.30232915]

# [-0.13689176]

# [ 0.74737671]

# [ 0.58641912]

# [ 0.14419141]]

print(a.T)

#[[-0.30232915 -0.13689176  0.74737671  0.58641912  0.14419141]]

3、矩阵乘法（点积)

(1)

import numpy as np

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

B = np.array([[5,6],[7,8]])

#点积

print(np.dot(A,B))

#array([[19, 22],[43, 50]])

(2)

a = np.random.randn(5,1)

b = a.T

# （5,1）(1,5)的点积得到的是5*5的矩阵

print(np.dot(a,b))

# （1,5）(5,1)的点积得到的是1*1的矩阵

print(np.dot(b,a))

4、矩阵求逆

\(AB=E\)，矩阵A与B互为逆矩阵，其中E为单位矩阵，E的行列式计算为1



A = np.matrix('1,2;3,4')

print(A.I)#求逆

#[[-2.   1. ]

# [ 1.5 -0.5]]

E = np.dot(A,A.I)

print(E)

#[[1.0000000e+00 0.0000000e+00]

#[8.8817842e-16 1.0000000e+00]]

value = np.linalg.det(E)#行列式计算

#0.9999999999999996

4、算术运算



x = np.array([1.0,2.0,3.0])

y = np.array([2.0,3.0,4.0])

#减法

print(x - y)

# [-1. -1. -1.]

#加法

print(x + y)

#[3. 5. 7.]

#乘法

print(x * y)

#[ 2.  6. 12.]

#除法

print(x / y)

#[0.5        0.66666667 0.75      ]

#开方根

print(np.sqrt(x))

#[1.         1.41421356 1.73205081]

#对数

print(np.log(x))

#[0.         0.69314718 1.09861229]

# 指数

print(np.exp(a))

# [ 2.71828183  7.3890561  20.08553692]

5、平均值、方差、标准差



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

# 平均值

np.mean([1,2,3,4])

# 3.5

# 方差

print(np.var(x))

#2.9166666666666665

# 标准差

print(np.std(x))

#1.707825127659933

五、应用

1、sigmoid函数

def sigmoid(x):

    s = 1.0 / (1.0 + np.exp(-x))

    return s

2、sigmoid求导



def sigmoid_derivative(x):

    s = sigmoid(x)

    ds = s*(1-s)

    return ds

3、softmax函数计算

def softmax(x):

    x_exp = np.exp(x)

    x_sum = np.sum(np.exp(x),axis=1,keepdims = True)

    s = x_exp / x_sum

    return s

4、计算损失函数



def L1(yhat, y):

    loss = np.sum(np.abs(yhat - y))

    return loss



def L1(yhat, y):

    loss = np.sum((y - yhat)**2)

    return loss

5、向量化练习



x1 = [9, 2, 5, 0, 0, 7, 5, 0, 0, 0, 9, 2, 5, 0, 0]

x2 = [9, 2, 2, 9, 0, 9, 2, 5, 0, 0, 9, 2, 5, 0, 0]

### VECTORIZED DOT PRODUCT OF VECTORS ###

tic = time.process_time()

dot = np.dot(x1,x2)

toc = time.process_time()

print ("dot = " + str(dot) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

### VECTORIZED OUTER PRODUCT ###

tic = time.process_time()

outer = np.outer(x1,x2)

toc = time.process_time()

print ("outer = " + str(outer) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

### VECTORIZED ELEMENTWISE MULTIPLICATION ###

tic = time.process_time()

mul = np.multiply(x1,x2)

toc = time.process_time()

print ("elementwise multiplication = " + str(mul) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

### VECTORIZED GENERAL DOT PRODUCT ###

tic = time.process_time()

dot = np.dot(W,x1)

toc = time.process_time()

print ("gdot = " + str(dot) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

参考文档

Numpy 1.15.4官方文档

神经网络和深度学习-吴恩达——Vectorization

numpy基本方法总结

巴特西

深度学习之Numpy整理