机器学习笔记（六）：numpy基础

继加减乘除之后，我们继续深入。数字世界就像我们现实的世界一样，一个螺栓只有跟它相匹配的螺母才能安装在一起。假设我们的机器学习算法就是那个螺栓，我们需要将数据加工成与其匹配的形式才能输入。让我们一起创造这个需要的螺母吧。

我将加工制造数据的过程分成两个大的部分：

1、从无到有

2、从有到你需要的

一、创建需要的数据

1.1 有规律的数列

首先，是我们最熟悉的等差、等比数列。

#生成数列
def numpyArray():
print np.arange(0,1,0.1)#(开始值，终值，步长)，已知差值的等差数列
print np.linspace(0,1,12)#(开始值，终值，元素个数)，已知个数的等差数列
print np.logspace(0,2,10)#(10的开始值次方，10的终值次方，元素个数),已知个数的等比数列

输出结果：

>>> numpyDemo1.numpyArray()
[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]
[ 0.          0.09090909  0.18181818  0.27272727  0.36363636  0.45454545
0.54545455  0.63636364  0.72727273  0.81818182  0.90909091  1.        ]
[   1.            1.66810054    2.7825594     4.64158883    7.74263683
12.91549665   21.5443469    35.93813664   59.94842503  100.        ]

总结一下：

等差：arange：已知：初始值，终值，步长（公差） 得：数列

等差：linspace: 已知：初始值，终值，数列个数N 得：数列

等比：logspace: 已知：初始值，终值，数列个数N 得：数列，其中，初始值和终值均用 10x 来表示，x就是我们输入的（0,2）

我们最常用的是arange，如：arange（100）产生一个0-99的序列

1.2 随机数

随机数，在我们测试程序中，经常用到。随机数在numpy的random模块中。

#生成简单随机数
def randomArray():
print np.random.random(3)#生成一维0=<x<1的随机数，只能生成一维
print np.random.rand(3,3)#可生成多维数组，0=<x<1
print np.random.uniform(10,20,3)#带范围的随机数全开区间（10,20）,个数3
print np.random.choice([1,2,3,4,5,6],3)#从一个序列中，随机返回3个数
print np.random.sample(3)#效果同random相同

输出结果：

>>> numpyDemo1.randomArray()
#random(3)
[ 0.39672676  0.44733682  0.61819711]
#rand(3,3)
[[ 0.01305821  0.8695998   0.30605922]
[ 0.11279212  0.8603538   0.56720643]
[ 0.03876075  0.79332307  0.70867722]]
#uniform(10,20,3)
[ 16.40704848,  10.53822399,  12.20177289]
#choice([1,2,3,4,5,6],3)
[2 4 3]
#sample(3)
[ 0.33565689  0.17051657  0.07909578]

1.3 0或者1构成的特殊序列

#特殊的序列
def ufunc1():
print np.ones(3)#一维的a(i)=1
print np.ones([3,2])#多维的a(ij)=1
print np.zeros(3)#一维的a(i)=0
print np.zeros([3,2])#多维的a(ij)=0
#empty 空列表
print np.empty(3)
#eye 单位矩阵
print np.eye(3,3)

输出结果：

>>> numpyDemo1.ufunc1()
[ 1.  1.  1.]
[[ 1.  1.]
[ 1.  1.]
[ 1.  1.]]
[ 0.  0.  0.]
[[ 0.  0.]
[ 0.  0.]
[ 0.  0.]]
[  4.24399236e-314   1.69759663e-313   0.00000000e+000]
[[ 1.  0.  0.]
[ 0.  1.  0.]
[ 0.  0.  1.]]

1.4 调整数组的维度

先创建一个数组

>>> a=np.arange(9)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8])

1.4.1 reshape方法

调整数组的维度

>>> np.reshape(a,(3,3))
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])

1.4.2 tile方法

按照维度复制数组

>>> np.tile(a,(3,2))
array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8],
[0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8],
[0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8]])

二、加工需要的数据

在机器学习算法中，经常需要针对数据的每一组数据进行类似：x2i−y2i−−−−−−√ 或者 tanyixi 运算。除了numpy入门 中的加减乘除运算，我们还有乘方、三角函数、指数、对数等等各种运算，下面分别来学习一下。

2.1 元素加工

def ufunc3():
x=np.arange(0,10,0.1)#产生一个[0,0.1,...,10.0)序列
#sin
y1=np.sin(x)
#cos
y2=np.cos(x)
#tan
y3=np.tan(x)
#另外反三角函数为：arccos,arcsin,arctan
#绝对值：abs，fabs（不能计算复数）
y4=np.abs(x)
#平方根：sqrt
y5=np.sqrt(x)
#平方：square
y6=np.square(x)
#exp:指数函数：e的x次方
y7=np.exp(x)
#log:e为底,log10：10为底,log2：2为底,log1p：log(1+x)
y8=np.log(y7)

我将各个函数的计算结果，进行了数据可视化。具体实现过程可以参考我的笔记：matplotlib入门和matplotlib基础



大家可以看出，像加减乘除一样，都是对序列中的每个元素进行运算的。这样可以节省我们大量时间，不用再去写for循环了。我将常用的函数总结如下，后续会跟随着我学习的脚步继续更新。

方法	说明
sin	三角函数，sin(x)，反函数arcsin:arcsin(x)
cos	三角函数，cos(x)，反函数arccos:arccos(x)
tan	三角函数，tan(x)，反函数arctan:arctan(x)
abs	绝对值，|x|
sqrt	平方根，x√
square	平方，x2
exp	指数函数，ex
log	对数函数，log(x)

2.2 数据统计

套用一句歌词“在开始的开始，先创建一个随机数序列”，不然我们演示就变成了有锅无菜，你再高超的厨艺也无法发挥出来。

dataArray=np.random.randn(100,3)#创建一个100行X3列的随机数数组
print dataArray

输出结果：

因为数组行数实在太多，我进行了省略。randn函数和rand类似，暂且大家只需这样理解就行。在后面我统计学函数中将逐步明白其是怎么回事。

[[  4.88724795e-01   3.36064056e-01   2.37948334e-01]
[  6.95633615e-01   3.79764560e-01   3.95604628e-01]
[  1.10620948e+00  -2.67534107e+00   9.19226332e-01]
......
[ -6.21655335e-01   7.83808807e-01   7.85454112e-01]
[ -3.62451577e-01  -3.43259437e-01  -1.40353700e+00]
[  2.16275273e-01  -5.28517366e-01  -1.76889428e+00]]

我还是秉承我一贯的做笔记风格，已实例说话，在用的过程中，顺便把知识学了，偏理论和需要融会贯通的内容，将在进阶和高级笔记中进行深度剖析。话不多说，每个函数先写一个Demo，然后有个初步的感性认识并且知道其基础用法。

2.2.1 sum函数

求和函数，分为三种：总和，按行求和，按列求和

#sum：求和
print np.sum(dataArray)
print np.sum(dataArray,axis=0)#按列求和
print np.sum(dataArray,axis=1)#按行求和

输出结果：

#总和
-0.552668561603
#按列求和
[-0.57109681 -5.83941414  5.85784238]
#按行求和，共100个数据，已省略部分
[ 1.06273718  1.4710028  -0.64990526 -1.56714744
......
1.29018095  0.94760758 -2.10924801 -2.08113638]

因为后续的机器学习中，我们将大量运用按行求和（平均数等等其他方法），按列求和（平均数等等其他方法）的方法，我们对其核心参数axis 进行详细阐述一下：

axis: 顾名思义，就是轴的意思，大家想象一个笛卡尔坐标系（即常用的十字坐标系），我们有一个100X3的数组，横着就是x轴，竖着就是 y 轴，当axis=0时，按 y 轴求和，当axis=1时，按 x 轴求和。

以下的平均数、最大值、最小值、标准差、方差均可以用axis=0,1表示按列或者行运算，后面几个函数大家大概浏览一下，可以直接跳到我总结的表格了。

2.2.2 mean函数

#mean：求平均数
print np.mean(dataArray)
print np.mean(dataArray,axis=0)
print np.mean(dataArray,axis=1)

输出结果：

#总平均数
-0.00184222853868
#按列
[-0.00571097 -0.05839414  0.05857842]
#按行
[ 0.35424573  0.49033427 -0.21663509 -0.52238248
......
0.43006032  0.31586919 -0.70308267 -0.69371213]

2.2.3 std函数

#std：标准差
print np.std(dataArray)#总体
print np.std(dataArray,axis=0)#列
print np.std(dataArray,axis=1)#行

输出结果：

#总体
0.962683546652
#列
[ 0.95143311  0.9511511   0.98158123]
#行
[ 0.10318313  0.14531252  1.74024271  0.33934372
......
0.62156874  0.66293029  0.49535797  0.81881684]

2.2.4 var函数

#var：方差
print np.var(dataArray)#总体
print np.var(dataArray,axis=0)#列
print np.var(dataArray,axis=1)#行

输出结果：

#总体
0.926759610994
#列
[ 0.90522496  0.90468842  0.96350171]
#行
[ 0.01064676  0.02111573  3.02844467  0.11515416
......
0.3863477   0.43947657  0.24537952  0.67046102]

方差和标准差是统计数值的离散程度最常用的函数，二者满足：标准差的平方=方差

随机数dataArray 均值≈0，标准差≈1，这就是randn函数和rand函数的区别

2.2.5 max,min,argmax,argmin函数

最大值、最小值也可以通过axis=0,1来实现按列、按行求最大值、最小值。

#min,max:最大值，最小值
print np.min(dataArray)#总体
print np.min(dataArray,axis=0)#列
print np.min(dataArray,axis=1)#行

print np.max(dataArray)#总体
print np.max(dataArray,axis=0)#列
print np.max(dataArray,axis=1)#行

输出结果：

#最小值
#总体
-2.6753410705
#列
[-2.39678171 -2.67534107 -2.16313755]
#行
[ 0.23794833  0.37976456 -2.67534107 -0.99456704
......
-0.43090264 -0.62165534 -1.403537   -1.76889428]
#最大值
#总体
3.00183815303
#列
[ 1.92696733  2.87272368  3.00183815]
#行
[ 0.48872479  0.69563362  1.10620948 -0.21204367
......
1.01409517  0.78545411 -0.34325944  0.21627527]

最大值和最小值如果我们不需要其value（值），而需要其在array中位置，就可以用argmax和argmin函数

#argmin,argmax:索引最大和最小值
print np.argmax(dataArray)#总体
print np.argmax(dataArray,axis=0)#列
print np.argmax(dataArray,axis=1)#行

输出结果：

#argmax
107
#总体，300个数据中，第107个是最大值
[88 42 35]
#列，第0列，第1列，第2列的最大值分别是[第0列，第88行][第1列，第42行][第2列，第35行]对应的数值
[0 0 0 1 2 2 2 0 0 2 1 2 1 1 0 2 2 0 2 0 1 0 2 0 1 0 1 1 2 2 1 2 2 2 2 2 0
0 2 2 2 0 1 1 0 2 1 2 0 2 0 0 2 1 2 1 0 0 2 1 2 1 2 2 0 2 1 1 1 1 0 1 0 0
1 0 1 1 2 0 0 2 2 1 0 0 2 1 0 1 0 0 2 0 0 1 0 2 1 0]
#行
#从第0行到第99行，每一行所对应的最大值位置,因为共三列，因此只能能是0,1,2三个数字

2.2.6 cumsum,cumprod函数

#cumsum:累计和,类似于阶乘
a=np.array([[1,2,3],[4,5,6]])
print np.cumsum(a)
print np.cumsum(a,axis=0)
print np.cumsum(a,axis=1)
#cumprod:累计乘
print np.cumprod(a)
print np.cumprod(a,axis=0)
print np.cumprod(a,axis=1)

输出结果：

[ 1  3  6 10 15 21]#累加
#按列累加
[[1 2 3]
[5 7 9]]
#按行累加
[[ 1  3  6]
[ 4  9 15]]
#阶乘
[  1   2   6  24 120 720]
#按列阶乘
[[ 1  2  3]
[ 4 10 18]]
#按行阶乘
[[  1   2   6]
[  4  20 120]]

2.3 排序

多维数组的排序，我认为这是numpy中最好用的函数之一。大大简化了我们编程过程，并且程序执行效率也非常高。

1、先定义一个数组（3X3）

numArray=np.array([[1,3,2],[5,2,6],[7,9,8]])

2、默认排序法

print np.sort(numArray)
print np.sort(numArray,axis=-1)#默认就是-1

输出结果：

#axis不设置
[[1 2 3]
[2 5 6]
[7 8 9]]
#axis=-1
[[1 2 3]
[2 5 6]
[7 8 9]]

可以看出，默认是按照行排序的。

3、总体排序

print np.sort(numArray,axis=None)#全部排序，返回一维

输出结果：

[1 2 2 3 5 6 7 8 9]

4、按列排序

print np.sort(numArray,axis=0)#按列，返回二维

输出结果：

[[1 2 2]
[5 3 6]
[7 9 8]]

5、排序后，返回索引值

跟求最大值和最小值一样，同样也可以求其排序以后的索引值。我不再累述axis参数的功能。

#argsort:只返回索引
print np.argsort(numArray)#默认按行
print np.argsort(numArray,axis=None)#全部排序，返回一维
print np.argsort(numArray,axis=0)#按列，返回二维

输出结果：

>>>
#按行
[[0 2 1]#[第0行][列索引]
[1 0 2]#[第1行][列索引]
[0 2 1]]#[第2行][列索引]
#总体
[0 2 4 1 3 5 6 8 7]
#按列
[[0 1 0]#[行索引][第0列]
[1 0 1]#[行索引][第1列]
[2 2 2]]#[行索引][第2列]

需要注意的是：sorted,在numpy中无此方法。在numpy中的sort跟python中的sorted是一样的，不改变原序列的顺序。这是python中的函数，因为其比较复杂将在后续笔记中专门做一个比较。

每节课之后，让我们做一个练习题，一是，可以作为本节课的回顾。二是，做为下节课的开头。

练习题：已知A⃗ (0.2,0.8),B⃗ (0.8,0.2) 两点，求x⃗ i(0.3,0.6) 距离此两点的距离，并按距离远近对A,B两点进行排序，将排序后的结果返回。答案将在下节课揭晓。