关于机器学习:前置机器学习三30分钟掌握常用NumPy用法

1次阅读

共计 7076 个字符，预计需要花费 18 分钟才能阅读完成。

NumPy 反对大量的维度数组与矩阵运算，是针对数组运算的 Python 库。

本文收录于机器学习前置教程系列。

一、Python 根底

咱们首先坚固一下 Python 的基础知识。Python 有 6 种规范数据类型：Number（数字）,String（字符串）,List（列表）,Tuple（元组）,Set（汇合）,Dictionary（字典）。
其中：
不可变数据：Number（数字）、String（字符串）、Tuple（元组）。
可变数据：List（列表）、Dictionary（字典）、Set（汇合）。

1. List[列表]

列表由方括号 [] 包裹，每个地位的数值可变。

list = [1, 2, 3, 4, 5, 6]

依据地位取值，如取第 2 个地位的值：

list[1]

失去 2。
从第 3 个地位取值，到列表开端的所有值：

a[2:]

失去 [3, 4, 5, 6]。

扭转指定地位的值：

list[0] = 9

列表 a 此时输入为 [9, 2, 3, 4, 5, 6]。

2. Tuple(元组)

元组由圆括号 () 包裹，每个地位的数值 不可变 。容许数据 反复。

tuple = ('a', 'a,'c', 1, 2, 3.0)

输入 ('a', 'a', 'c', 1, 2, 3.0)。
取最初一个地位的元素：

tuple[-1]

输入 3.0。

元组操作与列表相似，但不可扭转元组内元素的值，否则会报错。

tuple[2] = 'caiyongji'

3. Set{汇合}

汇合是蕴含 不反复 元素的个体，由花括号 {} 包裹。

set1 = {'a','b','c','a'}
set2 = {'b','c','d','e'}

set1 的输入后果为：{'a', 'b', 'c'}。留神：汇合会删除反复元素。
set2 的输入后果为：{'b', 'c', 'd', 'e'}。

与列表和元组不同，汇合是不可下标的，如：

set1[0]

上面，咱们来看看汇合运算。

set1 和 set2 的 差集：

set1 - set2
#set1.difference(set2)

输入：{'a'}。

set1 和 set2 的 并集：

set1 | set2
#set1.union(set2)

输入：{'a', 'b', 'c', 'd', 'e'}。

set1 和 set2 的 交加：

set1 & set2
#set1.intersection(set2)

输入：{'b', 'c'}。

set1 和 set2 的 对称差集：

set1 ^ set2 
#(set1 - set2) | (set2 - set1)
#set1.symmetric_difference(set2)

输入：{'a', 'd', 'e'}。

以上差集、并集、交加、对称差集都有对应的汇合办法，能够正文办法本人试试。

4. Dictionary{字典:Dictionary}

字典是一种映射关系，是无序有键值对（key-value）汇合。字典不容许反复的键(key)，但容许反复的值(value)。

dict = {'gongzhonghao':'caiyongji','website':'caiyongji.com', 'website':'blog.caiyongji.com'}

字典输入{'gongzhonghao': 'caiyongji', 'website': 'blog.caiyongji.com'}，须要留神的是，当字典蕴含反复键，前面的会笼罩后面的元素。

dict['gongzhonghao']

输入字符串 caiyongji。咱们也能够应用 get 办法失去雷同成果。

dict.get('gongzhonghao')

查看所有的键(key):

dict.keys()

输入 dict_keys(['gongzhonghao', 'website'])。

查看所有的值(value):

dict.values()

输入 dict_values(['caiyongji', 'blog.caiyongji.com'])。
扭转某一项的值：

dict['website'] = 'caiyongji.com'
dict

输入 {'gongzhonghao': 'caiyongji', 'website': 'caiyongji.com'}。

理解了 Python 的数据类型，咱们能够学着应用 NumPy 了。

二、Numpy 常见用法

1. 创立数组

import numpy as np
arr = np.array([1, 2, 3, 4, 5])

arr 的输入为array([1, 2, 3, 4, 5])。

咱们输出以下代码创立二维数组：

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

mtrx 的输入如下：

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

2. 索引与切片

索引一维数组与二位数组如下：

print('arr[0]=',arr[0],'mtrx[1,1]=',mtrx[1,1])

输入 arr[0]= 1 mtrx[1,1]= 5。

对数组切片：

arr[:3]

输入后果为 array([1, 2, 3])。

倒数切片：

arr[-3:-1]

输入 array([3, 4])。

退出步长(step)，步长决定了切片距离：

arr[1:4:2]

输入 array([2, 4])。

二维数组切片：

mtrx[0:2, 0:2]

输入，代码意义为取第 1、2 行，第 1、2 列：

array([[1, 2],
       [4, 5]])

3. dtype

NumPy 的 dtpe 有如下几种数据类型：

  • i – integer
  • b – boolean
  • u – unsigned integer
  • f – float
  • c – complex float
  • m – timedelta
  • M – datetime
  • O – object
  • S – string
  • U – unicode string
  • V – fixed chunk of memory for other type (void)
import numpy as np
arr1 = np.array([1, 2, 3, 4])
arr2 = np.array(['apple', 'banana', 'cherry'])
print('arr1.dtype=',arr1.dtype,'arr2.dtype=',arr2.dtype)

输入为 arr1.dtype= int32 arr2.dtype= <U6。arr1 数据类型为 int32，arr2 的 <U6 示意不超过 6 位 Unicode 字符串。

咱们能够指定 dtype 类型。

arr = np.array(['1', '2', '3'], dtype='f')

输入后果位 array([1., 2., 3.], dtype=float32)，其中 1. 示意 1.0，能够看到 dtype 被设置位 float32 数据类型。

4. 个别办法

4.1 arange

np.arange(0,101,2)输入后果如下，该命令示意，在 [0,101) 区间内平均地生成数据，距离步长为 2。

array([  0,   2,   4,   6,   8,  10,  12,  14,  16,  18,  20,  22,  24,
        26,  28,  30,  32,  34,  36,  38,  40,  42,  44,  46,  48,  50,
        52,  54,  56,  58,  60,  62,  64,  66,  68,  70,  72,  74,  76,
        78,  80,  82,  84,  86,  88,  90,  92,  94,  96,  98, 100])

4.2 zeros

np.zeros((2,5))输入后果如下，该命令示意，输入 2 行 5 列全为 0 的矩阵（二维数组）。

array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

4.3 ones

np.ones((4,4))输入后果如下，该命令示意，输入 4 行 4 列全为 1 的矩阵。

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

4.4 eye

np.eye(5)输入后果如下，该命令示意，输入对角线为 1 其余全为 0 的 5 行 5 列方阵。方阵为行列雷同的矩阵。

array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

4.5 rand

np.random.rand(5,2) 命令生成 5 行 2 列的随机数。

array([[0.67227856, 0.4880784],
       [0.82549517, 0.03144639],
       [0.80804996, 0.56561742],
       [0.2976225 , 0.04669572],
       [0.9906274 , 0.00682573]])

如果想保障随机出与本例一样的随机数，可应用与本例雷同的随机种子。通过 np.random.seed 办法设置。

np.random.seed(99)
np.random.rand(5,2)

4.6 randint

np.random.randint(0,101,(4,5))输入后果如下，该命令示意，在 [0,101) 区间内随机选取 整数 生成 4 行 5 列的数组。

array([[1, 35, 57, 40, 73],
       [82, 68, 69, 52,  1],
       [23, 35, 55, 65, 48],
       [93, 59, 87,  2, 64]])

4.7 max min argmax argmin

咱们先随机生成一组数：

np.random.seed(99)
ranarr = np.random.randint(0,101,10)
ranarr

输入：

array([1, 35, 57, 40, 73, 82, 68, 69, 52,  1])

查看最大最小值别离为：

print('ranarr.max()=',ranarr.max(),'ranarr.min()=',ranarr.min())

输入后果为 ranarr.max()= 82 ranarr.min()= 1。
其中最大值和最小值的索引地位别离为：

print('ranarr.argmax()=',ranarr.argmax(),'ranarr.argmin()=',ranarr.argmin())

输入：ranarr.argmax()= 5 ranarr.argmin()= 0。留神，当呈现多个最大最小值时，取后面的索引地位。

三、NumPy 进阶用法

1. reshape

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
newarr = arr.reshape(4, 3)

其中，arr 为一维数组，newarr 为二位数组，其中行为 4，列为 3。

print('arr.shape=',arr.shape,'newarr.shape=',newarr.shape)

输入 arr.shape= (12,) newarr.shape= (4, 3)。

newarr的输入后果如下：

array([[1,  2,  3],
       [4,  5,  6],
       [7,  8,  9],
       [10, 11, 12]])

2. 合并与宰割

2.1 concatenate

一维数组合并：

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.concatenate((arr1, arr2))
arr

输入：array([1, 2, 3, 4, 5, 6])。

二维数组合并：

arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
arr = np.concatenate((arr1, arr2))
arr

输入为：


array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

咱们增加参数axis=1：

arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
arr = np.concatenate((arr1, arr2), axis=1)
arr

输入为：

array([[1, 2, 5, 6],
       [3, 4, 7, 8]])

咱们把鼠标移到 concatenate，按快捷键 Shift+Tab 查看办法阐明。能够看到 concatenate 办法沿着现有的轴进行合并操作，默认 axis=0。当咱们设置 axis= 1 后，合并操作沿着列进行。

2.2 array_split

宰割数组：

arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]])
newarr = np.array_split(arr, 3)
newarr

newarr 的值为：

[array([[1, 2],
        [3, 4]]),
 array([[5, 6],
        [7, 8]]),
 array([[9, 10],
        [11, 12]])]

3. 搜寻与筛选

3.1 搜寻

NumPy 可通过 where 办法查找满足条件的数组索引。

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
x = np.where(arr%2 == 0)
x

输入：

(array([1, 3, 5, 7], dtype=int64),)

3.2 筛选

咱们看看上面的代码：

bool_arr = arr > 4
arr[bool_arr]

输入：array([5, 6, 7, 8])。这回咱们返回的是数组中的值，而非索引。
咱们看看 bool_arr 的内容到底是什么。
bool_arr的输入为：

array([False, False, False, False,  True,  True,  True,  True])

所以咱们能够用以下命令代替以上筛选。

arr[arr > 4]

4. 排序

sort办法可对 ndarry 数组进行排序。

arr = np.array(['banana', 'cherry', 'apple'])
np.sort(arr)

输入排序后的后果：array(['apple', 'banana', 'cherry'], dtype='<U6')。

针对二维数组，sort办法对每一行独自排序。

arr = np.array([[3, 2, 4], [5, 0, 1]])
np.sort(arr)

输入后果：

array([[2, 3, 4],
       [0, 1, 5]])

5. 随机

5.1 随机概率

如果咱们想实现如下需要该如何解决？

生成蕴含 100 个值的一维数组，其中每个值必须为 3、5、7 或 9。
将该值为 3 的概率设置为 0.1。
将该值为 5 的概率设置为 0.3。
将该值为 7 的概率设置为 0.6。
将该值为 9 的概率设置为 0。

咱们用如下命令解决：

random.choice([3, 5, 7, 9], p=[0.1, 0.3, 0.6, 0.0], size=(100))

输入后果：

array([7, 5, 7, 7, 7, 7, 5, 7, 5, 7, 7, 5, 5, 7, 7, 5, 3, 5, 7, 7, 7, 7,
       7, 7, 7, 7, 7, 7, 5, 3, 7, 5, 7, 5, 7, 3, 7, 7, 3, 7, 7, 7, 7, 3,
       5, 7, 7, 5, 7, 7, 5, 3, 5, 7, 7, 5, 5, 5, 5, 5, 7, 7, 7, 7, 7, 5,
       7, 7, 7, 7, 7, 5, 7, 7, 7, 7, 3, 7, 7, 5, 7, 5, 7, 5, 7, 7, 5, 7,
       7, 7, 7, 7, 7, 3, 5, 5, 7, 5, 7, 5])

5.2 随机排列

5.2.1 permutation

依据原有数组生成新的随机排列。

np.random.seed(99)
arr = np.array([1, 2, 3, 4, 5])
new_arr = np.random.permutation(arr)
new_arr

输入为：array([3, 1, 5, 4, 2])。原数组 arr 不变。

5.2.2 shuffle

扭转原有数组为随机排列。shuffle 在英文中有洗牌的意思。

np.random.seed(99)
arr = np.array([1, 2, 3, 4, 5])
np.random.shuffle(arr)
arr

输入为：array([3, 1, 5, 4, 2])。原数组 arr 扭转。

5.3 随机散布

5.3.1 正太散布

应用 np.random.normal 办法生成合乎正太散布的随机数。

x = np.random.normal(loc=1, scale=2, size=(2, 3))
x

输入后果为：

array([[0.14998973,  3.22564777,  1.48094109],
       [2.252752  , -1.64038195,  2.8590667]])

如果咱们想查看 x 的随机散布，需装置 seaborn 绘制图像。应用 pip 装置：

pip install -i https://pypi.tuna.tsinghua.ed… seaborn

import matplotlib.pyplot as plt
import seaborn as sns
sns.distplot(x, hist=False)
plt.show()

5.3.2 二项分布

应用 np.random.binomial 办法生成合乎二项分布的随机数。

x = np.random.binomial(n=10, p=0.5, size=10)
x

输入后果为：array([8, 6, 6, 2, 5, 5, 5, 5, 3, 4])。

绘制图像：

import matplotlib.pyplot as plt
import seaborn as sns
sns.distplot(x, hist=True, kde=False)
plt.show()

5.3.3 多项式散布

多项式散布是二项分布的个别示意。应用 np.random.multinomial 办法生成合乎多项式散布的随机数。

x = np.random.multinomial(n=6, pvals=[1/6, 1/6, 1/6, 1/6, 1/6, 1/6])
x

下面代码，咱们能够简略了解为投掷骰子。n= 6 为骰子的面，pvals 示意每一面的概率为 1 /6。

5.3.4 其余

除以上散布外还有泊松散布、均匀分布、指数分布、卡方散布、帕累托散布等。感兴趣的可自行搜寻。

本文收录于机器学习前置教程系列。欢送大家点赞、珍藏、关注，更多对于机器学习的精彩内容继续更新中……!

正文完
机器学习
发表至： 机器学习
2020-12-06
 0
关于机器学习:机器学习的Tricks随机权值平均优化器swa与pseudolabel伪标签
关于机器学习:AI近十年盘点纵览AI发展历程探寻AI未来走向
关于机器学习:数据标注训练数据与测试数据为什么要拆分丨曼孚科技
关于机器学习:论文推荐谷歌Masked-Generative-Transformers-以更高的效率实现文本到图像的-SOTA

站内搜索

-「」