凌云时刻 · 技术
导读:NumPy是Python中的一个类库,它支持高阶维度数组(矩阵)的创建及各种操作、运算,是我们在机器学习中经常会使用的一个类库。这一节再看一些NumPy的矩阵用法。
作者 | 计缘
来源 | 凌云时刻(微信号:linuxpk)
NumPy也提供了生成随机数和随机元素数组的方法,我们来看一下:
# 生成从0到10之间的随机数
np.random.randint(0, 10)
# 结果
3
# 生成元素从0到10,一共4个随机元素的数组
np.random.randint(0, 10, size=4)
# 结果
array([4, 7, 8, 1])
# 生成元素随机从0到10,3行5列的矩阵
np.random.randint(0, 10, size=(3, 5))
# 结果
array([[6, 9, 7, 0, 9],
[7, 4, 8, 7, 8],
[4, 4, 9, 7, 2]])
如果我们希望每次使用随机方法生成的结果都是一样的,一般调试时候有这个需求,此时NumPy的random()
方法也提供了方便简单的方式,既随机种子的概念:
# 生成随机矩阵前给定一个种子
np.random.seed(123)
# 然后生成随机矩阵
np.random.randint(0, 10, size=(4, 5))
# 结果
array([[2, 2, 6, 1, 3],
[9, 6, 1, 0, 1],
[9, 0, 0, 9, 3],
[4, 0, 0, 4, 1]])
# 再次生成随机矩阵时,只要传入相同的种子,就可以得到相同结果的矩阵
np.random.seed(123)
np.random.randint(0, 10, size=(4, 5))
# 结果
array([[2, 2, 6, 1, 3],
[9, 6, 1, 0, 1],
[9, 0, 0, 9, 3],
[4, 0, 0, 4, 1]])
# 默认范围是从0.0到1.0,返回值为float型
np.random.random()
# 结果
0.18249173045349998
# 传入的参数是数组的大小
np.random.random(10)
# 结果
array([ 0.17545176, 0.53155137, 0.53182759, 0.63440096, 0.84943179,
0.72445532, 0.61102351, 0.72244338, 0.32295891, 0.36178866])
# 创建4行5列,元素值的范围从0.0到1.0的矩阵
np.random.random((4, 5))
# 结果
array([[ 0.22826323, 0.29371405, 0.63097612, 0.09210494, 0.43370117],
[ 0.43086276, 0.4936851 , 0.42583029, 0.31226122, 0.42635131],
[ 0.89338916, 0.94416002, 0.50183668, 0.62395295, 0.1156184 ],
[ 0.31728548, 0.41482621, 0.86630916, 0.25045537, 0.48303426]])
我们先来看看均值、方差、标准差的概念。均值很好理解,就是所有样本数据的平均值,描述了样本集合的中间点:
方差是衡量样本点和样本期望值相差的度量值:
标准差描述的是样本集合的各个样本点到均值的距离之平均:
标准差也就是对方差开根号。举个例子,[0, 8, 12, 20]
和[8, 9, 11, 12]
,两个集合的均值都是10,但显然两个集合的差别是很大的,计算两者的标准差,前者是8.3后者是1.8,显然后者较为集中,标准差描述的就是这种散布度或者叫做波动大小。综上,方差的意义在于描述随机变量稳定与波动、集中与分散的状况。标准差则体现随机变量取值与其期望值的偏差。
NumPy也提供了指定均值和标准差生成随机数的方法,我们来看一下:
# 第一个参数是均值,第二个参数是标准差
np.random.normal(10, 100)
# 结果
53.781947121910044
# 创建均值为10,方差为100的3行5列矩阵
np.random.normal(10, 100, size=(3, 5))
# 结果
array([[ 124.10915759, 27.14517732, -144.95788359, -87.40234817,
-94.91106048],
[ -36.4834381 , -39.05598871, 110.07456975, 224.85141913,
153.24092557],
[ -3.33533336, 10.57740526, -56.76208107, -84.06189149,
103.08098119]])
# 创建一个正态分布的3行5列矩阵,既均值为0,标准差为1
np.random.normal(0, 1, size=(3, 5))
# 结果
array([[-0.94574322, 2.0742057 , 0.34477911, 0.1375712 , 0.45385364],
[-2.07928914, 1.26474497, 1.56236822, -1.0032234 , -0.14807477],
[ 0.01992922, 0.3924738 , -0.11268871, 2.04509319, 0.01095378]])
# 生成10个元素的一维数组和3行5列的矩阵
import numpy as np
x = np.arange(10)
X = np.arange(15).reshape(3, 5)
x
X
# 结果
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
# 查看x的维度
x.ndim
# 结果
1
# 查看X的维度
X.ndim
# 结果
2
# 查看数组每个维度的具体信息
x.shape
# 结果
(10,)
X.shape
# 结果
(3, 5)
# 一维数组访问第1个元素
x[0]
# 结果
0
# 一维数组访问最后一个元素
x[-1]
# 结果
9
# 二维数组访问第3行,第4列的元素
X[2, 3]
# 结果
13
Python中,有一个获取数组片段非常方便的方法,叫做切片,numpy.array
中同样支持切片,我们来看一下:
# 获取x数组中从第1个元素到第5个元素的片段
x[0:5]
# 结果
array([0, 1, 2, 3, 4])
# 如果冒号前不指定位置,那么默认从第一个元素开始
x[:3]
# 结果
array([0, 1, 2])
# 如果冒号后面不指定位置,那么默认取到最后一个元素
x[3:]
# 结果
array([3, 4, 5, 6, 7, 8, 9])
# 切片也支持步长
x[0:10:2]
# 结果
array([0, 2, 4, 6, 8])
x[::2]
# 结果
array([0, 2, 4, 6, 8])
# 取X矩阵的前2行,前3列
X[:2, :3]
# 结果
array([[0, 1, 2],
[5, 6, 7]])
# 对于每个维度都可以指定步长
X[:2, ::2]
# 结果
array([[0, 2, 4],
[5, 7, 9]])
一般将高维矩阵降为低维矩阵其实也是使用切片来处理:
# 取X矩阵所有行的第一列
X[:, 0]
# 结果
array([ 0, 5, 10])
另外需要注意的是通过切片获取NumPy的数组或者矩阵的子数组,子矩阵是通过引用方式的,而Python中的数组通过切片获取的子数组是拷贝方式的。NumPy主要是考虑到性能效率问题。我们来看一下:
# 取X矩阵的前2行,前3列作为子矩阵
subX = X[:2, :3]
subX
# 结果
array([[0, 1, 2],
[5, 6, 7]])
# 给subX矩阵的第1行,第1列的元素赋值
subX[0, 0] = 100
subX
# 结果
array([[100, 1, 2],
[ 5, 6, 7]])
# 再看看X矩阵
X
# 结果
array([[100, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[ 10, 11, 12, 13, 14]])
# 复制子矩阵
subX1 = X[:2, :3].copy()
subX1
# 结果
array([[100, 1, 2],
[ 5, 6, 7]])
subX1[0, 0] = 0
subX1
# 结果
array([[0, 1, 2],
[5, 6, 7]])
X
# 结果
array([[100, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[ 10, 11, 12, 13, 14]])
NumPy也提供了修改数组维度的方法,我们来看看:
# x是一个一维数组
x
# 结果
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 将x改为二维数组,既2行5列的矩阵
x.reshape(2, 5)
x
# 结果
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
# 如果想让NumPy自动计算某个维度的数,比如我只想将x转换为只有2列的矩阵,有多少行交给NumPy处理
x.reshape(-1, 2)
# 结果
array([[0, 1],
[2, 3],
[4, 5],
[6, 7],
[8, 9]])
NumPy也提供两个数组合并的操作:
x = np.arange(5)
x
# 结果
array([0, 1, 2, 3, 4])
y = np.arange(5)
y
# 结果
array([0, 1, 2, 3, 4])
# 将x,y这两个一维数组合并
np.concatenate([x, y])
# 结果
array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4])
z = np.array([6, 6, 6, 6, 6])
z
# 结果
array([6, 6, 6, 6, 6])
# 将x,y,z三个一维数组合并
np.concatenate([x, y, z])
# 结果
array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 6, 6, 6, 6, 6])
多维数组也支持合并:
# 2行3列的矩阵
V = np.random.randint(0, 10, size=(2, 3))
V
# 结果
array([[9, 2, 0],
[8, 0, 2]])
# 将两个V矩阵合并
np.concatenate([V, V])
# 结果
array([[9, 2, 0],
[8, 0, 2],
[9, 2, 0],
[8, 0, 2]])
# 合并多维数组时,可以设置按照哪个维度合并,axis参数为0时按照行合并,axis参数为1时按照列合并,默认axis为0
np.concatenate([V, V], axis=1)
# 结果
array([[9, 2, 0, 9, 2, 0],
[8, 0, 2, 8, 0, 2]])
上面的示例都是同维度的数组进行合并,那么不同维度的数组如何合并呢,我们来看一下:
# z为一个一维数组
z = np.array([1, 2, 3])
z
# 结果
array([1, 2, 3])
# V为一个2行3列的矩阵
V
# 结果
array([[9, 2, 0],
[8, 0, 2]])
# 直接将V和z合并会抛异常
np.concatenate([V, z])
# 结果
ValueError: all the input arrays must have same number of dimensions
# 在合并时将一维数组z转变为二维数组
np.concatenate([V, z.reshape(1, -1)])
# 结果
array([[8, 2, 9],
[7, 3, 8],
[1, 2, 3]])
其实NumPy提供了更智能的不同维度数组合并的方法,我们来看一下:
# 按垂直方向合并
np.vstack([V, z])
# 结果
array([[8, 2, 9],
[7, 3, 8],
[1, 2, 3]])
# 创建一个2行2列的矩阵
V1 = np.full((2, 2), 10)
V1
# 结果
array([[10, 10],
[10, 10]])
# 按水平方向合并
np.hstack([V, V1])
# 结果
array([[ 8, 2, 9, 10, 10],
[ 7, 3, 8, 10, 10]])
有合并自然就会有分割,我们来看看NumPy提供的分割方法:
x = np.arange(10)
x
# 结果
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 对x进行分割,然后传入分割点,如下有两个分割点,所以将会把x分割为3个数组
x1, x2, x3 = np.split(x, [3, 7])
x1
x2
x3
# 结果
array([0, 1, 2])
array([3, 4, 5])
array([6, 7, 8, 9])
# 对于多维数组也是一样
X = np.arange(16).reshape((4, 4))
X
# 结果
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
# 传入一个分割点,既将X矩阵分割为两个矩阵
X1, X2 = np.split(X, [2])
X1
X2
# 结果
array([[0, 1, 2, 3],
[4, 5, 6, 7]])
array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])
# 分割多维数组同样可以设定按照哪个维度分割,axis默认为0,既按行分割
# axis为1时按列分割
X3, X4 = np.split(X, [2], axis=1)
X3
X4
# 结果
array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]])
array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])
和合并一样,分割也有更快接的方法:
# 按垂直方向分割,既按行分割
X5, X6 = np.vsplit(X, [2])
X5
X6
# 结果
array([[0, 1, 2, 3],
[4, 5, 6, 7]])
array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])
# 按水平方向分割,既按列分割
X7, X8 = np.hsplit(X, [2])
X7
X8
# 结果
array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]])
array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])
NumPy中提供了完整的矩阵的运算,我们从加减法来看一下:
# A为一个2行5列的矩阵
A = np.arange(10).reshape(2, 5)
A
# 结果
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
# B也是一个2行5列的矩阵
B = np.random.randint(0, 10, size=(2, 5))
B
# 结果
array([[4, 8, 3, 5, 7],
[9, 6, 6, 6, 6]])
# 矩阵加常数
A + 1
#结果
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10]])
# 矩阵减常数
A - 1
# 结果
array([[-1, 0, 1, 2, 3],
[ 4, 5, 6, 7, 8]])
# 矩阵加矩阵
A + B
# 结果
array([[ 4, 9, 5, 8, 11],
[14, 12, 13, 14, 15]])
# 矩阵减矩阵
A - B
# 结果
array([[-4, -7, -1, -2, -3],
[-4, 0, 1, 2, 3]])
下面我们再来看看数乘:
# 矩阵乘常数
2*A
# 结果
array([[ 0, 2, 4, 6, 8],
[10, 12, 14, 16, 18]])
# C为5行3列的矩阵
C = np.arange(15).reshape(5, 3)
C
# 结果
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11],
[12, 13, 14]])
# 矩阵乘矩阵,真正的矩阵相乘
A.dot(C)
# 结果
array([[ 90, 100, 110],
[240, 275, 310]])
# 矩阵中每个对应元素相乘
A*B
# 结果
array([[ 0, 8, 6, 15, 28],
[45, 36, 42, 48, 54]])
我们再来看看矩阵的转置:
A.T
# 结果
array([[0, 5],
[1, 6],
[2, 7],
[3, 8],
[4, 9]])
NumPy中有很多对数组的聚合操作方法,我们先来看看一维数组:
# 随机取10个元素的 一维数组
D = np.random.random(10)
D
# 结果
array([ 0.70908471, 0.29268356, 0.69885019, 0.28796429, 0.04189265,
0.36932107, 0.0641322 , 0.63989077, 0.02753356, 0.0605743 ])
# 求每个元素的和
np.sum(D)
# 结果
3.1919272951030706
# 求元素的最小值
np.min(D)
# 结果
0.027533561561906672
# 求元素最大值
np.max(D)
# 结果
0.70908470606410545
# 求元素的均值
np.mean(D)
# 结果
0.31919272951030708
# 求元素的标准差
np.std(D)
# 结果
0.26402525382852743
我们再来看看矩阵的聚合操作:
# X为2行3列的矩阵
X = np.arange(6).reshape(2, 3)
X
# 结果
array([[0, 1, 2],
[3, 4, 5]])
# 矩阵中所有元素的和
np.sum(X)
# 结果
15
# 矩阵中所有元素的乘积
np.prod(X)
# 结果
0
np.prod(X + 1)
# 结果
720
# 矩阵元素的均值
np.mean(X)
# 结果
2.5
# 矩阵元素的中位数,median可有效避免元素中出现极值,从而导致均值不准的问题
np.median(X)
# 结果
2.5
# 矩阵元素的方差
np.var(X)
# 结果
2.9166666666666665
# np.std(X)
# 结果
1.707825127659933
NumPy提供了一系列对数组索引操作的方法,我们来看一下:
# 随机一维数组
x = np.random.random(10)
x
# 结果
array([ 0.17035458, 0.8968506 , 0.01007584, 0.45925501, 0.6838149 ,
0.32393039, 0.53746647, 0.68561243, 0.66195346, 0.32696068])
# x中元素最小值
np.min(x)
# 结果
0.010075835471876626
# x中最小值元素所在的索引位置
np.argmin(x)
# 结果
2
我们再来看看排序:
# 对x进行排序
np.sort(x)
# 结果
array([ 0.01007584, 0.17035458, 0.32393039, 0.32696068, 0.45925501,
0.53746647, 0.66195346, 0.6838149 , 0.68561243, 0.8968506 ])
# 获取排序后的索引,返回的数组中的元素是索引
np.argsort(x)
# 结果
array([2, 0, 5, 9, 3, 6, 8, 4, 7, 1])
# 对矩阵排序
X1 = np.random.randint(0, 15, size=(3, 5))
X1
# 结果
array([[ 8, 1, 8, 12, 4],
[ 8, 6, 6, 6, 13],
[13, 2, 5, 11, 4]])
np.sort(X1)
# 结果
array([[ 1, 4, 8, 8, 12],
[ 6, 6, 6, 8, 13],
[ 2, 4, 5, 11, 13]])
# 获取排序后的索引
np.argsort(X1)
# 结果
array([[1, 4, 0, 2, 3],
[1, 2, 3, 0, 4],
[1, 4, 2, 3, 0]])
一般情况下我们访问NumPy数组的数据,可以使用索引,甚至可以用步长来取:
x = np.arange(16)
x
# 结果
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
# 取从0到6范围内,步长为2的元素
x[0:6:2]
# 结果
array([0, 2, 4])
但是有时候我们需要取数组中没有什么规律的元素,比如元素之间步长不等的,这就需要用到NumPy提供的Fancy Indexing机制来获取了:
# 将我们需要访问的索引生产一个数组,然后将索引数组传入x数组
ind = [3, 5, 8]
x[ind]
# 结果
array([3, 5, 8])
# 矩阵也是同样的,先生成索引矩阵
ind1 = np.array([[0, 1],
[2, 3]])
x[ind1]
# 结果
array([[0, 1],
[2, 3]])
# 将x转换为4行4列的矩阵X
X = x.reshape(4, -1)
X
# 结果
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
# 生成希望查询的行和列的索引矩阵,然后传入矩阵X
row = np.array([0, 1, 2])
col = np.array([1, 2, 3])
X[row, col]
# 结果
array([ 1, 6, 11])
# 或者指定前两行
X[:2, col]
# 结果
array([[1, 2, 3],
[5, 6, 7]])
除了使用指定索引以外,我们还可以使用布尔数组或者矩阵来使用Fancy Indexing,我们来看一下:
X
# 结果
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
# 生成一个布尔数组,True表示感兴趣的索引,False表示不感兴趣的索引
col = [True, False, True, True]
# 然后传入矩阵X,比如我们要获取前三行,第1列,第3列,第4列的元素
X[1:3, col]
# 结果
array([[ 4, 6, 7],
[ 8, 10, 11]])
x
# 结果
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
# x数组中的元素小于2的有几个
np.sum(x < 2)
# 结果
2
# x数组中的元素大于3小于10的有几个
np.sum((x > 3) & (x < 10))
# 结果
6
# 判断x数组中的所有元素是否满足一个条件,若有一个满足返回True,若都不满足返回False
np.any(x == 0)
# 结果
True
np.any(x < 0)
# 结果
False
# 判断x数组中的所有元素是否满足一个条件,若有所有元素都满足返回True,若有一个元素不满足返回False
np.all(X > 0)
# 结果
False
np.all(X >= 0)
# 结果
True
# 获取x数组中元素小于5的是哪几个元素
x[x < 5]
# 结果
array([0, 1, 2, 3, 4])
# 获取x数组中元素是偶数的是哪几个元素
x[x % 2 == 0]
# 结果
array([ 0, 2, 4, 6, 8, 10, 12, 14])
X
# 结果
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
X[:, 3]
# 结果
array([ 3, 7, 11, 15])
X[:, 3] % 3 == 0
# 结果
array([ True, False, False, True], dtype=bool)
X[X[:, 3] % 3 == 0, :]
# 结果
array([[ 0, 1, 2, 3],
[12, 13, 14, 15]])
Matplotlib
在Python中,除了有NumPy这种对数组操作的类库,还有一个类一个在机器学习中使用比较广泛的类库是Matplotlib,这是一个绘制二维图像的类库,我们来看一下:
# 首先导入matplotlib的类库
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
# 创建数组x,元素从0到10,一共100个元素
x = np.linspace(0, 10, 100)
# 对x数组求sin,获得siny
siny = np.sin(x)
# 使用matplotlib将x数组和y数组中的元素绘制出来
plt.plot(x, y)
plt.show()
# 可以同时绘制两条线
cosy = np.cos(x)
plt.plot(x, siny)
plt.plot(x, cosy)
plt.show()
# 可以指定某条线的颜色
plt.plot(x, siny)
plt.plot(x, cosy, color="red")
plt.show()
# 可以指定线的样式
plt.plot(x, siny)
plt.plot(x, cosy, color="red", linestyle="--")
plt.show()
# 可以指定x轴,y轴的区间
plt.plot(x, siny)
plt.plot(x, cosy, color="red", linestyle="--")
plt.xlim(-5, 15)
plt.ylim(0, 1.5)
plt.show()
# 另一种指定x轴,y轴区间的方法
plt.plot(x, siny)
plt.plot(x, cosy, color="red", linestyle="--")
plt.axis([-1, 11, -2, 2])
plt.show()
# 给x轴和y轴加说明
plt.plot(x, siny)
plt.plot(x, cosy, color="red", linestyle="--")
plt.axis([-1, 11, -2, 2])
plt.xlabel("x axis")
plt.ylabel("y value")
plt.show()
# 加图例
plt.plot(x, siny, label="sin(x)")
plt.plot(x, cosy, color="red", linestyle="--", label="cos(x)")
plt.axis([-1, 11, -2, 2])
plt.xlabel("x axis")
plt.ylabel("y value")
plt.legend()
plt.show()
# 加标题
plt.plot(x, siny, label="sin(x)")
plt.plot(x, cosy, color="red", linestyle="--", label="cos(x)")
plt.axis([-1, 11, -2, 2])
plt.xlabel("x axis")
plt.ylabel("y value")
plt.legend()
plt.title("Welcome to ML!")
plt.show()
以上都是利用matplotlib画折线图,下面来看看如何画散点图:
plt.scatter(x, siny)
plt.show()
plt.scatter(x, siny)
plt.scatter(x, cosy)
plt.show()
x = np.random.normal(0, 1, 100)
y = np.random.normal(0, 1, 100)
plt.scatter(x, y)
plt.show()
# 设置点的透明度
plt.scatter(x, y, alpha=0.5)
plt.show()
基于Scikit Learn的数据探索
Scikit-learn是Python语言中专门针对机器学习应用而发展起来的一款开源框架,其中有一个模块叫Datasets,它提供了机器学习的一些常用的数据集以及产生数据集的方法,比如波士顿房价数据集、乳腺癌数据集、糖尿病数据集、手写字体数据集、鸢尾花数据集等等。这一小节我们就通过Scikit Learn的Datasets来初步对机器学习的数据进行探索。
我们使用NumPy和Matplotlib对Scikit Learn Datasets中的鸢尾花这个数据集进行探索:
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
# 我们只导入Scikit Learn中的datasets模块
from sklearn import datasets
# 加载鸢尾花数据集,获取到的iris的数据结构是一个字典
iris = datasets.load_iris()
# 看看字典的key都有什么
iris.keys()
# 结果
dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names'])
从上面的示例可以看到鸢尾花这个字典一共包含五种信息,我们逐一来看看这五种信息:
# 先看一下DESCR信息,该信息解释了鸢尾花这个数据集
print(iris.DESCR)
# 结果
Iris Plants Database
====================
Notes
-----
Data Set Characteristics:
:Number of Instances: 150 (50 in each of three classes)
:Number of Attributes: 4 numeric, predictive attributes and the class
:Attribute Information:
- sepal length in cm
- sepal width in cm
- petal length in cm
- petal width in cm
- class:
- Iris-Setosa
- Iris-Versicolour
- Iris-Virginica
:Summary Statistics:
============== ==== ==== ======= ===== ====================
Min Max Mean SD Class Correlation
============== ==== ==== ======= ===== ====================
sepal length: 4.3 7.9 5.84 0.83 0.7826
sepal width: 2.0 4.4 3.05 0.43 -0.4194
petal length: 1.0 6.9 3.76 1.76 0.9490 (high!)
petal width: 0.1 2.5 1.20 0.76 0.9565 (high!)
============== ==== ==== ======= ===== ====================
.....
.....
DESCR
详细的描述了鸢尾花这个数据集一共有150组数据,每组数据有4个特征,分别是萼片的长度和厚度、花瓣的长度和厚度,还有3种鸢尾花的类别以及这些数据的统计信息和详细的解释说明。
# 再来看看data
iris.data
# 结果
array([[ 5.1, 3.5, 1.4, 0.2],
[ 4.9, 3. , 1.4, 0.2],
[ 4.7, 3.2, 1.3, 0.2],
[ 4.6, 3.1, 1.5, 0.2],
[ 5. , 3.6, 1.4, 0.2],
[ 5.4, 3.9, 1.7, 0.4],
[ 4.6, 3.4, 1.4, 0.3],
[ 5. , 3.4, 1.5, 0.2],
[ 4.4, 2.9, 1.4, 0.2],
[ 4.9, 3.1, 1.5, 0.1],
[ 5.4, 3.7, 1.5, 0.2],
[ 4.8, 3.4, 1.6, 0.2],
...
...
[ 5.9, 3. , 5.1, 1.8]])
# 看看data这个数组的行列情况
iris.data.shape
# 结果
(150, 4)
可以看到data
中的数据就是萼片长度、厚度,花瓣长度、厚度的值。是一个150行,4列的矩阵。
# feature_names的值就是4个特征的说明
iris.feature_names
# 结果
['sepal length (cm)',
'sepal width (cm)',
'petal length (cm)',
'petal width (cm)']
# target描述了每一行鸢尾花的数据是哪个类别的
iris.target
# 结果
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
# target是一个一维数组
iris.target.shape
# 结果
(150,)
# target_names就是类别名称
iris.target_names
# 结果
array(['setosa', 'versicolor', 'virginica'],
dtype='
关注
打赏
最近更新
- 深拷贝和浅拷贝的区别(重点)
- 【Vue】走进Vue框架世界
- 【云服务器】项目部署—搭建网站—vue电商后台管理系统
- 【React介绍】 一文带你深入React
- 【React】React组件实例的三大属性之state,props,refs(你学废了吗)
- 【脚手架VueCLI】从零开始,创建一个VUE项目
- 【React】深入理解React组件生命周期----图文详解(含代码)
- 【React】DOM的Diffing算法是什么?以及DOM中key的作用----经典面试题
- 【React】1_使用React脚手架创建项目步骤--------详解(含项目结构说明)
- 【React】2_如何使用react脚手架写一个简单的页面?


微信扫码登录