随机与分布函数

发布于 2024-05-19 17:57:20 字数 19765 浏览 0 评论 0 收藏 0

numpy 中的随机和分布函数模块有两种用法：函数式以及类式

1. 函数式

a. 随机数

numpy.random.rand(d0, d1, ..., dn) :指定形状 (d0, d1, ..., dn) 创建一个随机的 ndarray 。每个元素值来自于半闭半开区间 [0,1) 并且服从均匀分布。
- 要求 d0, d1, ..., dn 为整数
- 如果未提供参数，则返回一个随机的浮点数而不是 ndarray ，浮点数值来自于半闭半开区间 [0,1) 并且服从均匀分布。
numpy.random.randn(d0, d1, ..., dn) ：指定形状 (d0, d1, ..., dn) 创建一个随机的 ndarray 。每个元素值服从正态分布，其中正态分布的期望为 0，方差为 1
- 要求 d0, d1, ..., dn 为整数或者可以转换为整数
- 如果 di 为浮点数，则截断成整数
- 如果未提供参数，则返回一个随机的浮点数而不是 ndarray ，浮点数值服从正态分布，其中正态分布的期望为 0，方差为 1
numpy.random.randint(low[, high, size]) ：返回一个随机的整数 ndarray 或者一个随机的整数值。
- 如果 high 为 None ，则表示整数值都取自 [0,low) 且服从 discrete uniform 分布
- 如果 high 给出了值，则表示整数值都取自 [low,high) 且服从 discrete uniform 分布
- size 是一个整数的元组，指定了输出的 ndarray 的形状。如果为 None 则表示输出为单个整数值
numpy.random.random_integers(low[, high, size]) ：返回一个随机的整数 ndarray 或者一个随机的整数值。
- 如果 high 为 None ，则表示整数值都取自 [1,low] 且服从 discrete uniform 分布
- 如果 high 给出了值，则表示整数值都取自 [low,high] 且服从 discrete uniform 分布
- size 是一个整数的元组，指定了输出的 ndarray 的形状。如果为 None 则表示输出为单个整数值
它与 randint 区别在于 randint 是半闭半开区间，而 random_integers 是全闭区间
numpy.random.random_sample([size]) ：返回一个随机的浮点 ndarray 或者一个随机的浮点值，浮点值是 [0.0,1.0) 之间均匀分布的随机数
- size 为整数元组或者整数，指定结果 ndarray 的形状。如果为 None 则只输出单个浮点数
- 如果想生成 [a,b) 之间均匀分布的浮点数，那么你可以用 (b-a)*random_sample()+a
如果 size 有效，它的效果等于 numpy.random.rand(*size) ；如果 size 无效，它的效果等于 numpy.random.rand()
numpy.random.random([size]) ：等价于 numpy.random.random_sample([size])
numpy.random.ranf([size]) ：等价于 numpy.random.random_sample([size])
numpy.random.sample([size]) ：等价于 numpy.random.random_sample([size])
numpy.random.choice(a[, size, replace, p]) :从一维数组中采样产生一组随机数或者一个随机数
- a 为一位数组或者 int ，如果是 int 则采样数据由 numpy.arange(n) 提供，否则采用数据由 a 提供
- size 为整数元组或者整数，指定结果 ndarray 的形状。如果为 None 则只输单个值
- replace ：如果为 True 则采样不替换
- p ：为一维数组，用于指定采样数组中每个元素值的采样概率。如果为 None 则均匀采样。
- 如果参数有问题则抛出异常：比如 a 为整数但是小于 0，比如 p 不满足概率和为 1 ，等等。。
numpy.random.bytes(length) ：返回 length 长度的随机字节串。 length 指定字节长度。

b. 排列组合

numpy.random.shuffle(x) :原地随机混洗 x 的内容，返回 None 。 x 为 array-like 对象，原地修改它
numpy.random.permutation(x) ：随机重排 x ，返回重排后的 ndarray 。 x 为 array-like 对象，不会修改它
- 如果 x 是个整数，则重排 numpy.arange(x)
- 如果 x 是个数组，则拷贝它然后对拷贝进行混洗
  - 如果 x 是个多维数则只是混洗它的第 0 维

c. 概率分布函数

下面是共同参数： size 若非 None ，则它指定输出 ndarray 的形状。如果为 None ，则输出单个值。

numpy.random.beta(a, b[, size]) ：Beta 分布。其中 a,b 都是 Beta 分布的参数，要求非负浮点数。
- 贝塔分布为： $f(x;\alpha,\beta)=\frac {1}{B(\alpha,\beta)} x^{\alpha-1}(1-x)^{\beta-1} $，其中： $ B(\alpha,\beta)=\int_0^{1} t^{\alpha-1}(1-t)^{\beta-1},dt $
numpy.random.binomial(n, p[, size]) :二项分布。其中 n,p 都是二项分布的参数，要求 n 为大于等于 0 的浮点数，如果它为浮点数则截断为整数； p 为 [0,1] 之间的浮点数。
- 二项分布为：$ P(N)=\binom{n}{N}p^{N}(1-p)^{n-N}$
numpy.random.chisquare(df[, size]) :卡方分布。其中 df 为整数，是卡方分布的自由度（若小于等于 0 则抛出异常）。
- 卡方分布为： $ p(x)=\frac{(1/2)^{k/2}}{\Gamma(k/2)} x^{k/2-1}e^{-x/2}$，其中 $ \Gamma(x)=\int^{\infty}_0 t^{x-1}e^{-t},dt$
numpy.random.dirichlet(alpha[, size]) :狄利克雷分布。其中 alpha 是个数组，为狄利克雷分布的参数。
numpy.random.exponential([scale, size]) :指数分布。 scale 为浮点数，是参数 $ \beta $
- 指数分布的概率密度函数为:$ f(x;\frac {1}{\beta})=\frac{1}{\beta}\exp(-\frac{x}{\beta})$
numpy.random.f(dfnum, dfden[, size]) : F 分布。 dfnum 为浮点数，应该大于 0，是分子的自由度； dfden 是浮点数，应该大于 0，是分母的自由度。
numpy.random.gamma(shape[, scale, size]) :伽玛分布。其中 shape 是个大于 0 的标量，表示分布的形状； scale 是个大于 0 的标量，表示伽玛分布的 scale （默认为 1）。
- 伽玛分布的概率密度函数为:$p(x)=x^{k-1} \frac {e^{-x/\theta}}{\theta^{k}\Gamma(k)}$，其中 k 为形状， $\theta$ 为 scale
numpy.random.geometric(p[, size]) :几何分布。其中 p 是单次试验成功的概率。
- 几何分布为：$f(k)=(1-p)^{k-1}p$
numpy.random.gumbel([loc, scale, size]) :甘贝尔分布。其中 loc 为浮点数，是分布的 location of mode ， scale 是浮点数，为 scale 。
- 甘贝尔分布:$ p(x)=\frac {e^{-(x-\mu)/\beta}}{\beta} e^{-e-(x-\mu)/\beta}$，其中 $ \mu$ 为 location of mode ， $\beta $ 为 scale
numpy.random.hypergeometric(ngood, nbad, nsample[, size]) : 超几何分布。其中 ngood 为整数或者 array_like ，必须非负数，为好的选择； nbad 为整数或者 array_like ，必须非负数，表示坏的选择。
- 超级几何分布：$ P(x)= \frac {\binom{m}{n} \binom{N-m}{n-x}} {\binom{N}{n}}, 0 \le x \le m \ \text{and} \ n+m-N \le x \le n $，其中 n=ngood ， m=nbad ， N 为样本数量。 P(x) 为 x 成功的概率
numpy.random.laplace([loc, scale, size]) :拉普拉斯分布。 loc 为浮点数， scale 为浮点数
- 拉普拉斯分布：$f(x;\mu,\lambda)=\frac {1}{2\lambda} \exp(- \frac{|x-\mu|}{\lambda}) $，其中 loc =$\mu $ ， scale =$ \lambda $
numpy.random.logistic([loc, scale, size]) :逻辑斯谛分布。其中 loc 为浮点数， scale 为大于 0 的浮点数
- 逻辑斯谛分布： $P(x)= \frac {e^{-(x-\mu)/s}}{s(1+e^{-(x-\mu)/s})^{2}}$，其中 loc =$ \mu $, scale = $ s$
numpy.random.lognormal([mean, sigma, size]) :对数正态分布。其中 mean 为浮点数， sigma 为大于 0 的浮点数。
- 对数正态分布：$ p(x)=\frac {1}{\sigma x \sqrt{2\pi}} e^{-(\ln(x)-\mu)^{2}/(2\sigma^{2})}$，其中 mean =$\mu$ ， sigma = $ \sigma$
numpy.random.logseries(p[, size]) :对数分布，其中 p 为 [0.0--1.0] 之间的浮点数。
- 对数分布：$P(k)=\frac {-p^{k}}{k\ln(1-p)} $
numpy.random.multinomial(n, pvals[, size]) :多项式分布。 n 为执行二项分布的试验次数， pvals 为浮点序列，要求这些序列的和为 1，其长度为 n 。
numpy.random.multivariate_normal(mean, cov[, size]) :多元正态分布。 mean 为一维数组，长度为 N ； cov 为二维数组，形状为 (N,N)
numpy.random.negative_binomial(n, p[, size]) :负二项分布。 n 为整数，大于 0； p 为 [0.0--1.0] 之间的浮点数。
- 负二项分布：$ P(N;n,p)=\binom{N+n-1}{n-1}p^{n}(1-p)^{N} $
numpy.random.noncentral_chisquare(df, nonc[, size]) :非中心卡方分布。 df 为整数，必须大于 0; noc 为大于 0 的浮点数。
- 非中心卡方分布： $ P(x;k,\lambda)= \sum_{i=0}^{\infty } f_Y(x) \frac {e^{-\lambda/2}(-\lambda/2)^{i}}{i!} $
其中 $ Y=Y_{k+2i} $ 为卡方分布， df 为 k ， nonc 为 $ \lambda$
numpy.random.noncentral_f(dfnum, dfden, nonc[, size]) :非中心 F 分布。其中 dfnum 为大于 1 的整数， dfden 为大于 1 的整数， nonc 为大于等于 0 的浮点数。
numpy.random.normal([loc, scale, size]) :正态分布。其中 loc 为浮点数， scale 为浮点数。
- 正态分布： $p(x)=\frac {1}{\sqrt{2\pi\sigma^{2}}}e^{-(x-\mu)^{2}/(2\sigma^{2})} $，其中 loc =$ \mu $， scale =$ \sigma $
numpy.random.pareto(a[, size]) :帕累托分布。其中 a 为浮点数。
- 帕累托分布： $ p(x)= \frac {\alpha m ^{\alpha}}{x^{\alpha+1}}$，其中 a =$ \alpha $, m 为 scale
numpy.random.poisson([lam, size]) :泊松分布。其中 lam 为浮点数或者一个浮点序列（浮点数大于等于 0）。
- 泊松分布： $ f(k;\lambda)=\frac {\lambda^{k}e^{-\lambda}}{k!}$，其中 lam =$\lambda$
numpy.random.power(a[, size]) :幂级数分布。其中 a 为大于 0 的浮点数。
- 幂级数分布： $ P(x;a)=ax^{a-1},0\le x \le 1,a \gt 0 $
numpy.random.rayleigh([scale, size]) : 瑞利分布。其中 scale 为大于 0 的浮点数。
- 瑞利分布：$ P(x;\sigma)=\frac{x}{\sigma^{2}}e^{-x^{2}/(2\sigma^{2})}$，其中 scale =$ \sigma $
numpy.random.standard_cauchy([size]) :标准柯西分布。
- 柯西分布：$ P(x;x_0,\gamma)=\frac{1}{\pi\gamma[1+((x-x_0)/\gamma)^{2}]}$，其中标准柯西分布中， $ x_0=1,\gamma=1$
numpy.random.standard_exponential([size]) :标准指数分布。其中 scale 等于 1
numpy.random.standard_gamma(shape[, size]) :标准伽玛分布，其中 scale 等于 1
numpy.random.standard_normal([size]) :标准正态分布，其中 mean =0， stdev 等于 1
numpy.random.standard_t(df[, size]) :学生分布。其中 df 是大于 0 的整数。
- 学生分布: $ f(t;\nu)=\frac{\Gamma((\nu+1)/2)}{\sqrt{\nu\pi}\Gamma(\nu/2)}(1+t^{2}/\nu)^{-(\nu+1)/2}$，其中 df = $ \nu $
numpy.random.triangular(left, mode, right[, size]) : 三角分布。其中 left 为标量， mode 为标量， right 为标量
- 三角分布（其中 left = l ， mode = m ， right = r ）：

$$ P(x;l,m,r)= \left\{ \begin{matrix} \frac{2(x-l)}{(r-l)(m-l)}, & \text{for $l \le x \le m$} \\ \frac{2(r-x)}{(r-l)(r-m)}, & \text{for $m \le x \le r$} \\ 0, & \text{otherwise} \end{matrix} \right.$$

numpy.random.uniform([low, high, size]) :均匀分布。其中 low 为浮点数； high 为浮点数。
- 均匀分布：$ p(x)=\frac {1}{b-a}$，其中 low = a , high = b
numpy.random.vonmises(mu, kappa[, size]) : Mises 分布。其中 mu 为浮点数， kappa 为大于等于 0 的浮点数。
- Mises 分布：$p(x)= \frac{e^{\kappa \cos(x-\mu)}}{2\pi I_0(\kappa)} $，其中 mu =$ \mu $， kappa =$ \kappa $， $I_0(\kappa) $ 是 modified Bessel function of order 0
numpy.random.wald(mean, scale[, size]) : Wald 分布。其中 mean 为大于 0 的标量， scale 为大于等于 0 的标量
- Wald 分布：$ P(x;\mu,\lambda)=\sqrt{\frac {\lambda}{2\pi x^{3}}} \exp \{\frac{-\lambda(x-\mu)^{2}}{2\mu^{2}x}\}$，其中 mean =$ \mu $， scale =$\lambda $
numpy.random.weibull(a[, size]) ： Weibull 分布。其中 a 是个浮点数。
- Weibull 分布: $ p(x)= \frac {a}{\lambda} (\frac {x}{\lambda})^{a-1} e^{-(x/\lambda)^{a}}$，其中 a =$ a $，$ lambda $ 为 scale
numpy.random.zipf(a[, size]) :齐夫分布。其中 a 为大于 1 的浮点数。
- 齐夫分布： $ p(x)=\frac {x^{-a}}{\zeta(a)}$ ，其中 a =$a $， $ \zeta $ 为 Riemann Zeta 函数。

2. RandomState 类

类式用法主要使用 numpy.random.RandomState 类，它是一个 Mersenne Twister 伪随机数生成器的容器。它提供了一些方法来生成各种各样概率分布的随机数。

构造函数: RandomState(seed) 。其中 seed 可以为 None , int , array_like 。这个 seed 是初始化伪随机数生成器。如果 seed 为 None ，则 RandomState 会尝试读取 /dev/urandom 或者 Windows analogure 来读取数据，或用者 clock 来做种子。

Python 的 stdlib 模块 random 也提供了一个 Mersenne Twister 伪随机数生成器。但是 RandomState 提供了更多的概率分布函数。

RandomState 保证了通过使用同一个 seed 以及同样参数的方法序列调用会产生同样的随机数序列（除了浮点数精度上的区别）。

RandomState 提供了一些方法来产生各种分布的随机数。这些方法都有一个共同的参数 size 。

如果 size 为 None ，则只产生一个随机数
如果 size 为一个整数，则产生一个一维的随机数数组。
如果 size 为一个元组，则生成一个多维的随机数数组。其中数组的形状由元组指定。

a. 生成随机数的方法

.bytes(length) ：等效于 numpy.random.bytes(...) 函数
.choice(a[, size, replace, p]) ：等效于 numpy.random.choice(...) 函数
.rand(d0, d1, ..., dn) ：等效于 numpy.random.rand(...) 函数
.randint(low[, high, size]) ：等效于 numpy.random.randint(...) 函数
.randn(d0, d1, ..., dn) ：等效于 numpy.random.randn(...) 函数
.random_integers(low[, high, size]) ：等效于 numpy.random_integers.bytes(...) 函数
.random_sample([size]) ：等效于 numpy.random.random_sample(...) 函数
.tomaxint([size]) ：等效于 numpy.random.tomaxint(...) 函数

b. 排列组合的方法

.shuffle(x) ：等效于 numpy.random.shuffle(...) 函数
.permutation(x) ：等效于 numpy.random.permutation(...) 函数

c. 指定概率分布函数的方法

.beta(a, b[, size]) ：等效于 numpy.random.beta(...) 函数
.binomial(n, p[, size]) ：等效于 numpy.random.binomial(...) 函数
.chisquare(df[, size]) ：等效于 numpy.random.chisquare(...) 函数
.dirichlet(alpha[, size]) ：等效于 numpy.random.dirichlet(...) 函数
.exponential([scale, size]) ：等效于 numpy.random.exponential(...) 函数
.f(dfnum, dfden[, size]) ：等效于 numpy.random.f(...) 函数
.gamma(shape[, scale, size]) ：等效于 numpy.random.gamma(...) 函数
.geometric(p[, size]) ：等效于 numpy.random.geometric(...) 函数
.gumbel([loc, scale, size]) ：等效于 numpy.random.gumbel(...) 函数
.hypergeometric(ngood, nbad, nsample[, size]) ：等效于 numpy.random.hypergeometric(...) 函数
.laplace([loc, scale, size]) ：等效于 numpy.random.laplace(...) 函数
.logistic([loc, scale, size]) ：等效于 numpy.random.logistic(...) 函数
.lognormal([mean, sigma, size]) ：等效于 numpy.random.lognormal(...) 函数
.logseries(p[, size]) ：等效于 numpy.random.logseries(...) 函数
.multinomial(n, pvals[, size]) ：等效于 numpy.random.multinomial(...) 函数
.multivariate_normal(mean, cov[, size]) ：等效于 numpy.random.multivariate_normal(...) 函数
.negative_binomial(n, p[, size]) ：等效于 numpy.random.negative_binomial(...) 函数
.noncentral_chisquare(df, nonc[, size]) ：等效于 numpy.random.noncentral_chisquare(...) 函数
.noncentral_f(dfnum, dfden, nonc[, size]) ：等效于 numpy.random.noncentral_f(...) 函数
.normal([loc, scale, size]) ：等效于 numpy.random.normal(...) 函数
.pareto(a[, size]) ：等效于 numpy.random.pareto(...) 函数 - . poisson([lam, size]) ：等效于 numpy.random.poisson(...) 函数
.power(a[, size]) ：等效于 numpy.random.power(...) 函数
.rayleigh([scale, size]) ：等效于 numpy.random.rayleigh(...) 函数
.standard_cauchy([size]) ：等效于 numpy.random.standard_cauchy(...) 函数
.standard_exponential([size]) ：等效于 numpy.random.standard_exponential(...) 函数
.standard_gamma(shape[, size]) ：等效于 numpy.random.standard_gamma(...) 函数
.standard_normal([size]) ：等效于 numpy.random.standard_normal(...) 函数
.standard_t(df[, size]) ：等效于 numpy.random.standard_t(...) 函数
.triangular(left, mode, right[, size]) ：等效于 numpy.random.triangular(...) 函数
.uniform([low, high, size]) ：等效于 numpy.random.uniform(...) 函数
.vonmises(mu, kappa[, size]) ：等效于 numpy.random.vonmises(...) 函数
.wald(mean, scale[, size]) ：等效于 numpy.random.wald(...) 函数
.weibull(a[, size]) ：等效于 numpy.random.weibull(...) 函数
.zipf(a[, size]) ：等效于 numpy.random.zipf(...) 函数

d. 类式的其他函数

seed(seed=None) ：该方法在 RandomState 被初始化时自动调用，你也可以反复调用它从而重新设置伪随机数生成器的种子。
get_state() ：该方法返回伪随机数生成器的内部状态。其结果是一个元组 (str, ndarray of 624 uints, int, int, float) ，依次为：
- 字符串 'MT19937'
- 一维数组，其中是 624 个无符号整数 key
- 一个整数 pos
- 一个整数 has_gauss
- 一个浮点数 cached_gaussian
set_state(state) ：该方法设置伪随机数生成器的内部状态,如果执行成功则返回 None。参数是个元组 (str, ndarray of 624 uints, int, int, float)`，依次为：
- 字符串 'MT19937'
- 一维数组，其中是 624 个无符号整数 key
- 一个整数 pos
- 一个整数 has_gauss
- 一个浮点数 cached_gaussian