numpy——随机取样

numpy.random

numpy.random.seed()
seed()用于指定随机数生成时所用算法开始的整数值
seed()里的数字相当于设置了盛有随机数的“聚宝盆”，一个数字代表一个“聚宝盆”，当seed()的括号里设置相同的seed，“聚宝盆”就是一样的，那当然拿出的随机数就会是相同的。如果不设置seed，则每次生成不同的随机数。

离散型随机变量

二项分布（Binomial Distribution）
重复n次的伯努利试验，在每次实验中只有两种可能的结果，且事件之间相互独立。
二项分布概率函数的数学表示
P(x=k)=Cnkpk(1−p)n−kP(x=k)={C^k_n}{p^k}{(1-p)^{n-k}}P(x=k)=Cnkpk(1−p)n−k
二项分布概率函数的代码表示

binom.pmf(k) = choose(n, k) p**k (1-p)**(n-k)

Note：

numpy.random.binomial(n, p, size=None)

表示对一个二项分布进行采样，size表示采样的次数，n表示n次伯努利试验，p代表成功的概率，函数返回值表示n中成功的次数。

举例：
模拟投硬币，投两次，请问两次都为正面的概率？

import numpy as np
from scipy import stats
import matplotlib.pyplot as pltnp.random.seed(20200605)
n = 2# 做某件事情的次数,这里是投两次硬币
p = 0.5#做某件事情成功的概率，在这里即投硬币为正面的概率
size = 50000
x = np.random.binomial(n, p, size)
'''或者使用binom.rvs
#使用binom.rvs(n, p, size=1)函数模拟一个二项随机变量,可视化地表现概率
y = stats.binom.rvs(n, p, size=size)#返回一个numpy.ndarray
'''
print(np.sum(x == 0) / size)  # 0.25154
print(np.sum(x == 1) / size)  # 0.49874
print(np.sum(x == 2) / size)  # 0.24972plt.hist(x)
plt.xlabel('随机变量：硬币为正面次数')
plt.ylabel('50000个样本中出现的次数')
plt.show()
#它返回一个列表，列表中每个元素表示随机变量中对应值的概率
s = stats.binom.pmf(range(n + 1), n, p)
print(np.around(s, 3))

泊松分布（Poisson Distribution）
描述单位时间内随机事件发生的次数，满足一下条件：

1、在任意两个相等长度的区间上，事件发生的概率相等
2、事件在某一区间上是否发生与事件在其他区间上是否发生所独立

泊松分布概率函数的数学表示
P(x=k)=e−λλkk!e^{-\lambda}{\lambda^k}\over{k!}k!e−λλk
泊松分布概率函数的代码表示：

poisson.pmf(k)=exp(-lam)lam*k/k!

举例：
假定某航空公司预定票处平均每小时接到42次订购电话，那么十分钟内恰好街道6次电话的概率是多少？

import numpy as np
from scipy import stats
import matplotlib.pyplot as plt#首先设置种子
np.random.seed(20201124)
#设置size, lam
size = 5000; lam = 42 / 6;
#np.random.poisson(lam, size), stats.poisson.rvs(lam, size=size)
x = np.random.poisson(lam, size);
print(np.sum(x == 6) / size)plt.hist(x)
plt.xlabel('随机变量：每10分钟接到订票电话的次数')
plt.ylabel('5000个样本中出现的次数')
plt.show()#使用poisson.pmf(k, mu)来求对应的腹部密度：概率密度函数(pmf)
x = stats.poisson.pmf(6, lam)
print(x)

超几何分布
1、各次实验不是独立的
2、各次实验成功的概率也不是相等的
超几何概率函数的数学表示：
P(x=k)=CMkCN−Mn−kCNnC{^k_M}C{^{n-k}_{N-M}}\over C{^n_N}CNnCMkCN−Mn−k

numpy.random.hypergeometric(ngod,nbad,nsample,size=None)

表示对超几何分布进行采样，size表示采样的次数，ngod表示总体中具有成功标志的元素的个数，nbad表示总体中不具有成功标志的元素个数，ngod+nbad表示总样本容量，nsample表示抽取元素的次数，函数返回值表示抽取nsample个元素中具有成功标识的元素的个数。

import numpy as np
from scipy import stats
import matplotlib.pyplot as pltnp.random.seed(20200605)
size = 500000
x = np.random.hypergeometric(ngood=7, nbad=13, nsample=12, size=size)
'''或者
#用rvs(M, n, N, loc=0, size=1, random_state=None)模拟
x = stats.hypergeom.rvs(M=20,n=7,N=12,size=size)
'''
print(np.sum(x == 3) / size)  # 0.198664plt.hist(x, bins=8)
plt.xlabel('狗的数量')
plt.ylabel('50000个样本中出现的次数')
plt.title('超几何分布',fontsize=20)
plt.show()"""
M 为总体容量
n 为总体中具有成功标志的元素的个数
N,k 表示抽取N个元素有k个是成功元素
"""
x = range(8)
#用hypergeom.pmf(k, M, n, N, loc)来计算k次成功的概率
s = stats.hypergeom.pmf(k=x, M=20, n=7, N=12)
print(np.round(s, 3))
# [0.    0.004 0.048 0.199 0.358 0.286 0.095 0.01 ]

连续型随机变量

均匀分布(Uniform Distribution)
连续型随机变量X具有如下的概率密度函数，则称X服从[a,b]上的均匀分布
f(x)f(x)f(x)=1b−a1\over b-ab−a1 a<x<b

import numpy as np
import matplotlib.pyplot as plt
from scipy import statsnp.random.seed(20200614)
a = 0
b = 100
size = 50000
x = np.random.uniform(a, b, size=size)
print(np.all(x >= 0))  # True
print(np.all(x < 100))  # True  #np.all(x < tmp) 当x中所有数据都小于tmp返回True，否则返回False
y = (np.sum(x < 50) - np.sum(x < 10)) / size
print(y)  # 0.40144plt.hist(x, bins=20)
plt.show()a = stats.uniform.cdf(10, 0, 100) #0-100 的均匀分布得到P(x <= 10)
b = stats.uniform.cdf(50, 0, 100) #0-100 的均匀分布得到P(x <= 50)
print(b - a)  # 0.4

np.random.uniform() 不指定low 和 high，默认在[0, 1)
np.random.randint() 则可以取随机的整数

正态分布
依据中心极限定理，当样本量足够大时，样本均值的分布会趋于正态分布。
f(x)f(x)f(x)=exp(−(x−μ)22σ2-(x-\mu)^2\over{2\sigma^2}2σ2−(x−μ)2)12πσ1\over \sqrt{2\pi\sigma}2πσ1

import numpy as np
import matplotlib.pyplot as pltnp.random.seed(20200614)
x = 0.5 * np.random.randn(2, 4) + 5
'''或者
#模拟10000个随机变量
x = 0.5*stats.norm.rvs(size=(2,4))+5
'''
print(x)
# [[5.39654234 5.4088702  5.49104652 4.95817289]
#  [4.31977933 4.76502391 4.70720327 4.36239023]]np.random.seed(20200614)
mu = 5#平均值
sigma = 0.5#标准差
x = np.random.normal(mu, sigma, (2, 4))
print(x)
# [[5.39654234 5.4088702  5.49104652 4.95817289]
#  [4.31977933 4.76502391 4.70720327 4.36239023]]size = 50000
x = np.random.normal(mu, sigma, size)print(np.mean(x))  # 4.996403463175092
print(np.std(x, ddof=1))  # 0.4986846716715106（#样本标准差）
'''
ddof：int, optional
Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero.
'''
plt.hist(x, bins=20)
plt.show()

总体标准差：σ=∑(xi−x‾)2n\sigma={\sqrt{\sum(x_i-\overline x)^2\over n}}σ=n∑(xi−x)2
样本标准差：S=∑(xi−x‾)2n−1S={\sqrt{\sum(x_i-\overline x)^2\over n-1}}S=n−1∑(xi−x)2
标准误差：σn=σn\sigma_n={\sigma\over \sqrt n}σn=nσ
方差：标准差的平方

指数分布(Exponential Distribution)

相比于泊松分布表示单位时间内随机事件的平均发生次数，指数分布可用来表示独立事件发生的时间间隔。
数学表示：
f(x)=λe−λxf(x)={\lambda e^{-\lambda x}}f(x)=λe−λx x>0

import numpy as np
import matplotlib.pyplot as plt
from scipy import statsnp.random.seed(20200614)
lam = 7
size = 50000
x = np.random.exponential(1 / lam, size)
'''或者
#rvs(loc=0, scale=1/lam, size=size, random_state=None)模拟
'''
y1 = (np.sum(x < 1 / 7)) / size
y2 = (np.sum(x < 2 / 7)) / size
y3 = (np.sum(x < 3 / 7)) / size
print(y1)  # 0.63218
print(y2)  # 0.86518
print(y3)  # 0.95056plt.hist(x, bins=20)
plt.show()y1 = stats.expon.cdf(1 / 7, scale=1 / lam)  #Y， 期望
y2 = stats.expon.cdf(2 / 7, scale=1 / lam)
y3 = stats.expon.cdf(3 / 7, scale=1 / lam)
print(y1)  # 0.6321205588285577
print(y2)  # 0.8646647167633873
print(y3)  # 0.950212931632136

随机从序列中获取元素

umpy.random.choice(a, size=None, replace=True, p=None)

从序列中获取元素，若a为整数，元素取值从np.range(a)中随机获取；若a为数组，取值从a数组元素中随机获取。该函数还可以控制生成数组中的元素是否重复replace，以及选取元素的概率p。

import numpy as np
# 从[0,10)随机选三个，可重复
np.random.seed(20200614)
x = np.random.choice(10, 3)
print(x)  # [2 0 1]
#从[0, 10]选三个，概率如p所示，可重复
x = np.random.choice(10, 3, p=[0.05, 0, 0.05, 0.9, 0, 0, 0, 0, 0, 0])
print(x)  # [3 2 3]
#从[0,10)选三个，不可重复，概率如p
x = np.random.choice(10, 3, replace=False, p=[0.05, 0, 0.05, 0.9, 0, 0, 0, 0, 0, 0])
print(x)  # [3 0 2]aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']
x = np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])
print(x) # ['pooh' 'rabbit' 'pooh' 'pooh' 'pooh']np.random.seed(20200614)
x = np.random.randint(0, 10, 3) #均匀分布，从[0,10)选3个整数
print(x)  # [2 0 1]

对数据集进行洗牌操作

数据一般都是按照采集顺序排列的，但是在机器学习中很多算法都要求数据之间相互独立，所以需要先对数据集进行洗牌操作。

numpy.random.shuffle(x)

对x进行重排序，如果x为多维数组，只沿第 0 轴洗牌，改变原来的数组，输出为None

import numpy as npnp.random.seed(20200614)
x = np.arange(10)
np.random.shuffle(x)
print(x)
# [6 8 7 5 3 9 1 4 0 2]print(np.random.shuffle([1, 4, 9, 12, 15]))
# Nonex = np.arange(20).reshape((5, 4))
print(x)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]
#  [16 17 18 19]]np.random.shuffle(x)
print(x)
# [[ 4  5  6  7]
#  [ 0  1  2  3]
#  [ 8  9 10 11]
#  [16 17 18 19]
#  [12 13 14 15]]

练习题

创建一个形为5×3的二维数组，以包含5到10之间的随机数。
知识点：创建随机二维数组

import numpy as npx = np.random.randint(5, 11, (5, 3))
print(x)
'''
[[ 8  7  8][ 7  7  9][ 9  7  9][ 9 10  7][ 5 10  9]]'''