[人工智能]NumPy基础

理解NumPy

本文主要介绍NumPy的基础知识，NumPy是一个功能强大的Python库，允许更高级的数据操作和数学计算。

什么是NumPy

NumPy，来源自两个单词：Numerical和Python，是一个强大的Python库，主要用于多维数组的执行计算。它非常重视数组，允许你在Python中进行向量和矩阵计算，其许多底层函数是由C编写的。NumPy提供了大量的库函数和操作，可以轻松地进行数值计算，这类数字计算广泛用于以下任务：

• 机器学习模型：在编写机器学习算法时，需要对矩阵进行各种数值计算，例如矩阵乘法、换位、加法等。NumPy提供了一个非常好的库，用于简单（在编写代码方面）和快速（在速度方面）计算。NumPy数组用于存储训练数据和机器学习模型的参数。
• 图像处理和计算机图形学：计算机中的图像表示为多维数组。NumPy成为同样情况下最自然的选择。实际上，NumPy提供了一些优秀的库函数来快速处理图像，例如镜像图像、按特定角度旋转图像等。
• 数学任务：NumPy对于执行各种数学任务非常有用，如数值积分、微分、内插、外推等，因此当涉及到数学任务是，它形成了一种基于Python的MATLIB的快速替代。

安装

这里使用pip的方式进行安装。

    pip3 install numpy

NumPy数组

NumPy库的核心是数组对象或ndarray对象（n维数组）。使用NumPy数组，可以进行逻辑、统计和傅里叶变换等运算。创建NumPy数组有以下三种不同方式：

1. 使用NumPy内部功能函数
2. 从列表等其他Python的结构进行转换
3. 使用特殊的库函数

使用NumPy内部功能函数

Nump提供了用于创建数组的内置函数。

创建一个一维的数组

首先，创建一维数组或rank为1的数组。arange是一种广泛使用的函数，用于快速创建数组：将数值num传入arange函数，将会创建一个值范围为0到num的数组。

import Numpy as np
 
a = np.arange(20)
a

输出如下：

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

可以是用shape属性验证此数组的维度：

In [11]: a.shape                                   
Out[11]: (20,)

创建一个二维数组

如果只是arange函数，它将输出一个一维数组，要使其成为一个二维数组，可以使用reshape函数链接其输出：

# 首先创建20个整数，然后将数组转换成4行5列的二维数组
In [12]: a = np.arange(20).reshape(4,5)              
 
In [13]: a                                  
Out[13]: 
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])
# 检查下数组的维度
In [14]: a.shape                                    
Out[14]: (4, 5)

创建三维数组及更多维度

要创建三维数组，那么需要为reshape函数指定3个参数。

# 注意，此时数组中元素的数量(27)必须是尺寸(3,3,3)的乘积
In [15]: a = np.arange(27).reshape(3,3,3)            
 
In [16]: a                                           
Out[16]: 
array([[[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8]],
 
       [[ 9, 10, 11],
        [12, 13, 14],
        [15, 16, 17]],
 
       [[18, 19, 20],
        [21, 22, 23],
        [24, 25, 26]]])
 
# 检查数组的维度
In [17]: a.shape                                       
Out[17]: (3, 3, 3)

使用其他NumPy函数

除了arange函数之外，还可以使用其他有用的函数，例如zeros和ones，来快速创建和填充数组。

使用zeros函数创建一个填充为零的数组，其参数表示行数和列数（或其维数）。

In [18]: np.zeros((2,4))                             
Out[18]: 
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.]])

使用ones函数创建一个填充为1的数组：

In [19]: np.ones((3,4))                              
Out[19]: 
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

empty函数创建一个数组，其初始内容是随机的，取决于内存的状态：

In [20]: np.empty((5,6))                              
Out[20]: 
array([[-2.31584178e+077, -2.00389912e+000,  2.30561760e-314,
         2.30789649e-314,  2.30702697e-314,  2.30772173e-314],
       [ 2.30796369e-314,  2.23928337e-314,  2.23928347e-314,
         2.30792536e-314,  2.23798476e-314,  2.30569256e-314],
       [-2.31584178e+077,  3.11108964e+231,  4.44659081e-323,
         0.00000000e+000, -0.00000000e+000,  0.00000000e+000],
       [ 5.45352918e-312,  4.94065646e-324,  4.94065646e-324,
         0.00000000e+000,  1.77229088e-310,  2.30690648e-314],
       [ 0.00000000e+000,  0.00000000e+000,  0.00000000e+000,
         2.30690648e-314,  2.30690648e-314,  2.08600674e-308]])

full函数创建一个填充给定值得n*n数组：

In [21]: np.full((5,5),6)                              
Out[21]: 
array([[6, 6, 6, 6, 6],
       [6, 6, 6, 6, 6],
       [6, 6, 6, 6, 6],
       [6, 6, 6, 6, 6],
       [6, 6, 6, 6, 6]])

eye函数创建一个n*n矩阵，其对角线为1，其余为0：

In [22]: np.eye(3,3)                                 
Out[22]: 
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

linspace函数在指定的时间间隔内返回均匀间隔的数组：

In [24]: np.linspace(0,20,num=5)                            
Out[24]: array([ 0.,  5., 10., 15., 20.])

从Python列表转换

创建一维数组

除了使用NumPy函数之外，还可以直接从Python列表创建数组：将Python列表传递给数组函数以创建NumPy数组：

In [25]: a = np.array([1,2,3])
 
In [26]: a   
Out[26]: array([1, 2, 3])

还可以创建Python列表并传递其变量名以创建NumPy数组：

In [27]: l = [4,5,6]
 
In [28]: l
Out[28]: [4, 5, 6]
 
In [29]: a = np.array(l)
 
In [30]: a
Out[30]: array([4, 5, 6])

创建二维数组

要创建二维数组，可以将一系列列表传递给数组函数：

In [31]: a = np.array([(1,2,3),(4,5,6)])                      
                                                       
In [32]: a
Out[32]: 
array([[1, 2, 3],
       [4, 5, 6]])
 
In [33]: a.shape
Out[33]: (2, 3)

使用特殊的库函数

除了上述的两种方式之外，还可以使用特殊库函数来创建数组。例如，要创建一个填充0到1之间随机值得数组，可以使用rando函数，这对于需要随机状态才能开始的问题特别有用。

In [34]: np.random.random((2,4))
Out[34]: 
array([[0.41392644, 0.21315258, 0.43934646, 0.46239945],
       [0.84670981, 0.81019245, 0.57370054, 0.74415838]])

数组索引

NumPy提供了几种索引数组的方法。

• 切片(Slicing)：与Python列表类似，可以对numpy数组进行切片，由于数组可能是多维的，因此必须为数组的每一维指定一个切片：

In [1]: import numpy as np
 
In [2]: a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]]) 
 
In [3]: b = a[:2,1:3]
 
In [4]: b
Out[4]: 
array([[2, 3],
       [6, 7]])
 
In [6]: a[0,1]
Out[6]: 2
 
In [7]: b[0,0] = 77
 
In [8]: a[0,1]
Out[8]: 77

还可以将整数索引与切片索引混合使用，但这样会产生比原始数组更低级别的数组。

• 整数数组索引：使用切片索引到numpy数组时，生成的数组始终是原始数组的子数组；使用整数数组索引允许你使用另一个数组中的数据构造任意数组。整数数组索引可以从矩阵的每一行中选择或改变一个元素。

• 布尔数组索引：布尔数组索引允许你选择数组的任意元素。通常，这种类型的索引用于选择满足某些条件的数组元素。

数据类型

每个numpy数组都是相同类型元素的网格。NumP提供了一组可用于构造数组的大量数值数据类型：NumPy在创建数组是尝试猜测数据类型，到构造数组的函数通常还包含一个可选参数来显示指定数据类型。

In [9]: a = np.array([1,2])
 
In [10]: a.dtype
Out[10]: dtype('int64')
 
In [11]: a = np.array([1.0,2.0])
 
In [12]: a.dtype
Out[12]: dtype('float64')
 
In [13]: a = np.array([1,2],dtype=np.int64)
 
In [14]: a.dtype                          
Out[14]: dtype('int64')

数组中的数学

基本数学函数在数组上以属性的方式运行，既可以作为运算符重载，也可以作为numpy模块的函数：

In [16]: x = np.array([[1,2],[3,4]],dtype=np.float64)
 
In [17]: y = np.array([[5,6],[7,8]],dtype=np.float64)
 
In [18]: x+y
Out[18]:
array([[ 6.,  8.],
       [10., 12.]])
 
In [19]: np.add(x,y)
Out[19]:
array([[ 6.,  8.],
       [10., 12.]])
 
In [20]: x-y
Out[20]:
array([[-4., -4.],
       [-4., -4.]])
 
In [21]: np.subtract(x,y)
Out[21]:
array([[-4., -4.],
       [-4., -4.]])
 
# * 是元素乘法，不是矩阵乘法
In [22]: x*y
Out[22]:
array([[ 5., 12.],
       [21., 32.]])
 
In [23]: np.multiply(x,y)
Out[23]:
array([[ 5., 12.],
       [21., 32.]])
 
In [24]: x/y
Out[24]:
array([[0.2       , 0.33333333],
       [0.42857143, 0.5       ]])
 
In [25]: np.divide(x,y)
Out[25]:
array([[0.2       , 0.33333333],
       [0.42857143, 0.5       ]])
 
In [26]: np.sqrt(x)
Out[26]:
array([[1.        , 1.41421356],
       [1.73205081, 2.        ]])
 
# 使用 dot函数计算向量的内积。dot既可以作为numpy模块中的函数，也可作为数组对象的实例方法
In [27]: x.dot(y)
Out[27]:
array([[19., 22.],
       [43., 50.]])
 
In [28]: np.dot(x,y)
Out[28]:
array([[19., 22.],
       [43., 50.]])

NumPy为在数组上执行计算提供了许多有用的函数，其中最有用的函数之一是SUM：

In [30]: x = np.array([[1,2],[3,4]])
 
In [31]: np.sum(x)
Out[31]: 10
 
In [32]: np.sum(x,axis=0) 
Out[32]: array([4, 6])
 
In [33]: np.sum(x,axis=1)
Out[33]: array([3, 7])

除了使用数组计算数学函数外，我们经常需要对数组中的数据进行整形或其他操作，这种操作的最简单的例子就是转置一个矩阵。要转置一个矩阵，只需要使用一个数组对象的T属性：

In [30]: x = np.array([[1,2],[3,4]])
 
In [34]: x
Out[34]:
array([[1, 2],
       [3, 4]])
 
In [35]: x.T
Out[35]:
array([[1, 3],
       [2, 4]])

除了上面提到的函数外，NumPy还提供了许多操作数组的函数，你可以在这篇文档中看到完整的列表。

广播（Broadcasting）

广播是一种强大的机制，它允许numpy在执行算术运算时使用不同形状的数组。

将两个数组一起广播遵循以下规则：

1. 如果数组具有不同的rank，则将较低等级数组的形状添加1，知道两个形状具有相同的长度。
2. 如果两个数组在维度上具有相同的大小，或者如果其中一个数组在该维度中的大小为1，则称这两个数组在维度上是兼容的。
3. 如果数组在所有维度上兼容，则可以一起广播。
4. 广播之后，每个阵列的行为就好像它的形状等于两个输入数组的形状的元素最大值。
5. 在一个数组的大小为1且另一个数组的大小大于1的任何维度中，第一个数组的行为就像沿着该维度复制一样。