第一章 机器学习基础（1） Numpy

机器学习基础（1） Numpy

1.Nmupy概述

	NumPy（Numerical Python）是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库
															--from 百度百科

​ Numpy提供了一个N维数类型nArray，其描述了相同的数据类型“items"的集合。

​ Numpy和python原生的list的区别：

	从图中我们可以看出ndarray在存储数据的时候，数据与数据的地址都是连续的，这样就给使得批量操作数组元素时速度更快。
	这是因为ndarray中的所有元素的类型都是相同的，而Python列表中的元素类型是任意的，所以ndarray在存储元素时内存可以连续，而python原生list就只能通过寻址方式找到下一个元素，这虽然也导致了在通用性能方面Numpy的ndarray不及Python原生list，但在科学计算中，Numpy的ndarray就可以省掉很多循环语句，代码使用方面比Python原生list简单的多。

2. Numpy的基本操作

本次教程设计的初衷只为了方便操作读取机器学习所提供的dataSet，因此比较浅显，如果想继续深入了解Numpy，请移步全球最大的同性交友平台gayHubNumpy中文文档地址

2.1 基本操作–取值、改值

​ 如果需要使用Numpy，则首先应该安装Numpy库，个人建议使用Anaconda进行安装。安装教程请移步Anaconda安装

​ 如果你已经有了Numpy库，则完全可以忽略上面那一步，在编译器中输入import numpy as np导入包，快快地和妲己愉快的玩耍吧~

​ 好了，不滑稽了~下面开始正题。首先导入操作所需要的先导数据。

## Numpy
import numpy as np  #导入包

##案例涉及的数值
a = np.array(['a','b','c','d','e'])
b = np.array([1,2,3,4,5])
c = np.array([6,7,8,9,10])
d = np.eye(4)   
print("a ===>",a)
print("b ===>",b)
print("c ===>",c)
print("d ===>",d)

所得到的结果为：

a ===> ['a' 'b' 'c' 'd' 'e']
b ===> [1 2 3 4 5]
c ===> [ 6  7  8  9 10]
d ===> [[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]

之后开始进行读取和操作：

##读取，修改
print(a[1])  ##output:'b'

##读取二维数组的指定值
print(d[1,1])  ##output:1.0

#读取1行
print(d[1])  ##output:[0. 1. 0. 0.]

#读取1列(ps:之所以不用d[:,2],是因为numpy是按照行存储，即二维矩阵的矩阵压缩)
print(d[:,2])  #output:[0. 0. 1. 0.]

##修改二维数组  
d[1,2] = 3
print(d) 
"""结果为：
[[1. 0. 0. 0.]
 [0. 1. 3. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]"""

2.2 基本操作–矩阵运算

## 矩阵的四则运算
##加
print(b+c)  #output:[ 7  9 11 13 15]

#减
print(b-c) #output:[-5 -5 -5 -5 -5]

#乘
print(b*c) #output:[ 6 14 24 36 50]

#除
print(b/c) #output:[0.16666667 0.28571429 0.375      0.44444444 0.5       ]

#次方运算
print(b**2) #output:[ 1  4  9 16 25]

2.3 基本操作–矩阵性质

在机器学习中，有很多地方需要知道矩阵的性质，比如维度，类型等。

##shape 返回各维度的长度 ,其返回值为一个元组
print(a.shape)  #output:(5,)
print(d.shape)  #output:(4, 4)

##维度运算  ndim
print(a.ndim) #1  ===>一维数组
print(d.ndim) #2 ===>二维数组

###dtype  查看numpy的类型
print(a.dtype)  #output:<U1
print(d.dtype)  #output:float64

##指定数据类型
arr = np.array([1,2.2,3,3.2],dtype="int32")
print(arr,arr.dtype)  #output:[1 2 3 3] int32
##如果遇到无法转换的数据类型，则会报错
##arr1 = ['1','2.2','a','ier',dtype="int32"]
##print(arr1)

##numpy数据类型的转换需要使用astype()，返回值是修改后的数据类型，而原始元组不变
arr = np.array([1,2.2,3.0,4,5,6.6])
e1 = arr.astype(int)
print(e1,e1.dtype) #output:[1 2 3 4 5 6] int32

e2 = arr.astype(np.str) ' '6.6'] 
print(e2,e2.dtype) #output:['1.0' '2.2' '3.0' '4.0' '5.0'] <U32

##显示最大元素的字节数 itemsize
print(a.itemsize) #output:4

##总元素字节数  nbytes
print(d.nbytes) #output:128

2.4 基本操作–Numpy函数

在机器学习中，有时候也会用到Numpy函数，比如tile,fill等，下面就跟随小弟一起来看看吧~

#fill 用指定的元素填充元组
# a.fill('a')
print(a) ##output:['a' 'a' 'a' 'a' 'a']

##重塑 reshape 在不改变原始数据的情况下，重新按指定形状生成数组
##array.reshape(a,b) 将array重组为a行b列的list
a = np.arange(1,25)  #np.arange(start,end)函数生成一个从start~end-1的list
#output:[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]

##如果元素个数不匹配，则会报错
#a.reshape(4,5) #output:ValueError

print(a.reshape(4,6))
#output:
'''
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]
 [13 14 15 16 17 18]
 [19 20 21 22 23 24]]
'''

###求和  sum种有一个axis的参数，能够指定列进行求和
'''
    假设a的形状是一个(2,3,2)的数组，则：
        IF axis=0(-3) THEN a在第0维（倒数第3维）上求和，得到一个（3，2）的数组
        IF axis=1(-2) THEN a在第1维（倒数第2维）上求和，得到一个（2，2）的数组
        IF axis=2(-1) THEN a在第2维（倒数第1维）上求和，得到一个（2，3）的数组
'''
a = np.arange(12).reshape(2,3,2)
'''
[[[ 0  1]
  [ 2  3]
  [ 4  5]]

 [[ 6  7]
  [ 8  9]
  [10 11]]]
'''
a_0 = a.sum(axis=0)
a_1 = a.sum(axis=1)
a_2 = a.sum(axis=2)

print(a_0,a_0.shape) #output: [[ 6  8][10 12][14 16]] (3, 2)
print(a_1,a_1.shape) #output:[[ 6  9][24 27]] (2, 2)
print(a_2,a_2.shape) #output: [[ 1  5  9][13 17 21]] (2, 3)

##tile函数 将原矩阵横向、纵向地复制。
##tile是瓷砖的意思，顾名思义，就是将矩阵像贴瓷砖一样平铺开来
##tile(matrix,(a,b))：先将matrix横向平铺b个，再将其纵向平铺a个。
import numpy as np
mat = np.array([[1,2],[3,4]])
print(mat)
tile(mat,4) #等于 tile(mat,(1,4)) ===>横向平铺4次 即[[1 2 1 2 1 2 1 2] [3 4 3 4 3 4 3 4]]

tile(mat,(3,1)) #纵向平铺3次,即[[1 2] [3 4][1 2] [3 4] [1 2] [3 4]]

#横向+纵向
tile(mat, (3, 4))
'''
结果：
[[1 2 1 2 1 2 1 2]
 [3 4 3 4 3 4 3 4]
 [1 2 1 2 1 2 1 2]
 [3 4 3 4 3 4 3 4]
 [1 2 1 2 1 2 1 2]
 [3 4 3 4 3 4 3 4]]
'''

2.5 基本操作–索引

索引被用于各种取数和循环等基本操作中，所以这个chapter非常的重要，但是非常的简单

##索引操作
#正索引         1，2，3，4，5，6
#负索引        -6,-5,-4,-3,-2,-1
a = np.array([10,5,8,9,2,1,64])
b = np.arange(20).reshape(4,5)

#切片
##一维切片
print(a[1:3])  #a[start:end]  start~end-1

print(a[3:])  #a[index:] start~最后一个元素

print(a[:3]) #a[:end] 第一个元素开始~a[3]

##负索引
print(a[-4:-2]) #a[-start,-end] 倒数第start个开始，一直到倒数第end+1结束

#a[::index] 每间隔index-1取一次
print(a[::2]) 

#区间跳转 a[开始：结束：间隔]
b = np.arange(10) #[0 1 2 3 4 5 6 7 8 9]
print(b[1:7:2]) #[1 3 5]

写在最后：

各位同学，请你们记住，在计算机领域中，最重要的事情是什么呢？实践，别人的东西终究是别人的，只有实践才能够将别人的东西转化成自己的，相信你们一定能够行的，加油~

最后，如果有志同道合的朋友想一起讨论的，请加QQ群【662151913】萌新AI的入坑之旅