统计学入门级：常见概率分布+python绘制分布图

如果随机变量X的所有取值都可以逐个列举出来，则称X为离散型随机变量。相应的概率分布有二项分布，泊松分布。

在柳江等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都网站设计、网站制作 网站设计制作按需开发,公司网站建设,企业网站建设,品牌网站设计,营销型网站,成都外贸网站建设,柳江网站建设费用合理。

如果随机变量X的所有取值无法逐个列举出来，而是取数轴上某一区间内的任一点，则称X为连续型随机变量。相应的概率分布有正态分布，均匀分布，指数分布，伽马分布，偏态分布，卡方分布，beta分布等。(真多分布，好恐怖~~)

在离散型随机变量X的一切可能值中，各可能值与其对应概率的乘积之和称为该随机变量X的期望值，记作E(X) 。比如有随机变量，取值依次为：2，2，2，4，5。求其平均值：(2+2+2+4+5)/5 = 3。

期望值也就是该随机变量总体的均值。 推导过程如下：

= (2+2+2+4+5)/5

= 1/5 2 3 + 4/5 + 5/5

= 3/5 2 + 1/5 4 + 1/5 5

= 0.6 2 + 0.2 4 + 0.2 5

= 60% 2 + 20% 4 + 20%*5

= 1.2 + 0.8 + 1

= 3

倒数第三步可以解释为值为2的数字出现的概率为60%，4的概率为20%，5的概率为20%。 所以E(X) = 60% 2 + 20% 4 + 20%*5 = μ = 3。

0-1分布（两点分布），它的随机变量的取值为1或0。即离散型随机变量X的概率分布为：P{X=0} = 1-p, P{X=1} = p，即：

则称随机变量X服从参数为p的0-1分布，记作X~B（1，p)。

在生活中有很多例子服从两点分布，比如投资是否中标，新生婴儿是男孩还是女孩，检查产品是否合格等等。

大家非常熟悉的抛硬币试验对应的分布就是二项分布。抛硬币试验要么出现正面，要么就是反面，只包含这两个结果。出现正面的次数是一个随机变量，这种随机变量所服从的概率分布通常称为 二项分布 。

像抛硬币这类试验所具有的共同性质总结如下：（以抛硬币为例）

通常称具有上述特征的n次重复独立试验为n重伯努利试验。简称伯努利试验或伯努利试验概型。特别地，当试验次数为1时，二项分布服从0-1分布(两点分布)。

举个栗子：抛3次均匀的硬币，求结果出现有2个正面的概率 。

已知p = 0.5 (出现正面的概率) ，n = 3 ，k = 2

所以抛3次均匀的硬币，求结果出现有2个正面的概率为3/8。

二项分布的期望值和方差 分别为：

泊松分布是用来描述在一 指定时间范围内或在指定的面积或体积之内某一事件出现的次数的分布 。生活中服从泊松分布的例子比如有每天房产中介接待的客户数，某微博每月出现服务器瘫痪的次数等等。 泊松分布的公式为 ：

其中 λ 为给定的时间间隔内事件的平均数，λ = np。e为一个数学常数，一个无限不循环小数，其值约为2.71828。

泊松分布的期望值和方差 分别为：

使用Python绘制泊松分布的概率分布图：

因为连续型随机变量可以取某一区间或整个实数轴上的任意一个值，所以通常用一个函数f(x)来表示连续型随机变量，而f(x)就称为 概率密度函数 。

概率密度函数f(x)具有如下性质 ：

需要注意的是，f(x)不是一个概率，即f(x) ≠ P(X = x) 。在连续分布的情况下，随机变量X在a与b之间的概率可以写成：

正态分布（或高斯分布）是连续型随机变量的最重要也是最常见的分布，比如学生的考试成绩就呈现出正态分布的特征，大部分成绩集中在某个范围（比如60-80分），很小一部分往两端倾斜（比如50分以下和90多分以上）。还有人的身高等等。

正态分布的定义 ：

如果随机变量X的概率密度为( -∞x+∞)：

则称X服从正态分布，记作X~N(μ,σ²)。其中-∞μ+∞，σ0， μ为随机变量X的均值，σ为随机变量X的标准差。 正态分布的分布函数

正态分布的图形特点 ：

使用Python绘制正态分布的概率分布图：

正态分布有一个3σ准则，即数值分布在(μ-σ,μ+σ)中的概率为0.6827，分布在（μ-2σ,μ+2σ)中的概率为0.9545，分布在(μ-3σ,μ+3σ)中的概率为0.9973，也就是说大部分数值是分布在(μ-3σ,μ+3σ)区间内，超出这个范围的可能性很小很小，仅占不到0.3%，属于极个别的小概率事件，所以3σ准则可以用来检测异常值。

当μ=0，σ=1时，有

此时的正态分布N(0,1) 称为标准正态分布。因为μ，σ都是确定的取值，所以其对应的概率密度曲线是一条 形态固定 的曲线。

对标准正态分布，通常用φ(x)表示概率密度函数，用Φ(x)表示分布函数：

假设有一次物理考试特别难，满分100分，全班只有大概20个人及格。与此同时语文考试很简单，全班绝大部分都考了90分以上。小明的物理和语文分别考了60分和80分，他回家后告诉家长，这时家长能仅仅从两科科目的分值直接判断出这次小明的语文成绩要比物理好很多吗？如果不能，应该如何判断呢？此时Z-score就派上用场了。 Z-Score的计算定义 ：

即 将随机变量X先减去总体样本均值，再除以总体样本标准差就得到标准分数啦。如果X低于平均值，则Z为负数，反之为正数 。通过计算标准分数，可以将任何一个一般的正态分布转化为标准正态分布。

小明家长从老师那得知物理的全班平均成绩为40分，标准差为10，而语文的平均成绩为92分，标准差为4。分别计算两科成绩的标准分数：

物理：标准分数 = (60-40)/10 = 2

语文：标准分数 = (85-95)/4 = -2.5

从计算结果来看，说明这次考试小明的物理成绩在全部同学中算是考得很不错的，而语文考得很差。

指数分布可能容易和前面的泊松分布混淆，泊松分布强调的是某段时间内随机事件发生的次数的概率分布，而指数分布说的是 随机事件发生的时间间隔 的概率分布。比如一班地铁进站的间隔时间。如果随机变量X的概率密度为：

则称X服从指数分布，其中的参数λ0。 对应的分布函数 为：

均匀分布的期望值和方差 分别为：

使用Python绘制指数分布的概率分布图：

均匀分布有两种，分为 离散型均匀分布和连续型均匀分布 。其中离散型均匀分布最常见的例子就是抛掷骰子啦。抛掷骰子出现的点数就是一个离散型随机变量，点数可能有1，2，3，4，5，6。每个数出现的概率都是1/6。

设连续型随机变量X具有概率密度函数：

则称X服从区间(a,b)上的均匀分布。X在等长度的子区间内取值的概率相同。对应的分布函数为：

f(x)和F(x)的图形分别如下图所示：

均匀分布的期望值和方差 分别为：

怎么从分子动力模拟中得到径向分布函数

简单来说是这样：

第一步，强度校正（去掉背景，偏振和吸收校正，compton散射校正）

第二步，归一化（换算成以电子单位表示的每个电子的散射强度）

第三步，计算结构因子F(Q)

第四步，傅里叶变换得到径向分布函数G(r)

第五步，误差处理（消除截断效应）

什么是径向分布函数

径向分布函数通常指的是给定某个粒子的坐标，其他粒子在空间的分布几率（离给定粒子多远）。所以径向分布函数既可以用来研究物质的有序性，也可以用来描述电子的相关性。

python rbf表示什么分布

径向基（RBF）神经网络python实现

1 from numpy import array, append, vstack, transpose, reshape, \

2                   dot, true_divide, mean, exp, sqrt, log, \

3                   loadtxt, savetxt, zeros, frombuffer

4 from numpy.linalg import norm, lstsq

5 from multiprocessing import Process, Array

6 from random import sample

7 from time import time

8 from sys import stdout

9 from ctypes import c_double

10 from h5py import File

11

12

13 def metrics(a, b):

14     return norm(a - b)

15

16

17 def gaussian (x, mu, sigma):

18     return exp(- metrics(mu, x)**2 / (2 * sigma**2))

21 def multiQuadric (x, mu, sigma):

22     return pow(metrics(mu,x)**2 + sigma**2, 0.5)

23

24

25 def invMultiQuadric (x, mu, sigma):

26     return pow(metrics(mu,x)**2 + sigma**2, -0.5)

27

28

29 def plateSpine (x,mu):

30     r = metrics(mu,x)

31     return (r**2) * log(r)

32

33

34 class Rbf:

35     def __init__(self, prefix = 'rbf', workers = 4, extra_neurons = 0, from_files = None):

36         self.prefix = prefix

37         self.workers = workers

38         self.extra_neurons = extra_neurons

39

40         # Import partial model

41         if from_files is not None:          

42             w_handle = self.w_handle = File(from_files['w'], 'r')

43             mu_handle = self.mu_handle = File(from_files['mu'], 'r')

44             sigma_handle = self.sigma_handle = File(from_files['sigma'], 'r')

45          

46             self.w = w_handle['w']

47             self.mu = mu_handle['mu']

48             self.sigmas = sigma_handle['sigmas']

49          

50             self.neurons = self.sigmas.shape[0]

51

52     def _calculate_error(self, y):

53         self.error = mean(abs(self.os - y))

54         self.relative_error = true_divide(self.error, mean(y))

55

56     def _generate_mu(self, x):

57         n = self.n

58         extra_neurons = self.extra_neurons

59

60         # TODO: Make reusable

61         mu_clusters = loadtxt('clusters100.txt', delimiter='\t')

62

63         mu_indices = sample(range(n), extra_neurons)

64         mu_new = x[mu_indices, :]

65         mu = vstack((mu_clusters, mu_new))

66

67         return mu

68

69     def _calculate_sigmas(self):

70         neurons = self.neurons

71         mu = self.mu

72

73         sigmas = zeros((neurons, ))

74         for i in xrange(neurons):

75             dists = [0 for _ in xrange(neurons)]

76             for j in xrange(neurons):

77                 if i != j:

78                     dists[j] = metrics(mu[i], mu[j])

79             sigmas[i] = mean(dists)* 2

80                       # max(dists) / sqrt(neurons * 2))

81         return sigmas

82

83     def _calculate_phi(self, x):

84         C = self.workers

85         neurons = self.neurons

86         mu = self.mu

87         sigmas = self.sigmas

88         phi = self.phi = None

89         n = self.n

90

91

92         def heavy_lifting(c, phi):

93             s = jobs[c][1] - jobs[c][0]

94             for k, i in enumerate(xrange(jobs[c][0], jobs[c][1])):

95                 for j in xrange(neurons):

96                     # phi[i, j] = metrics(x[i,:], mu[j])**3)

97                     # phi[i, j] = plateSpine(x[i,:], mu[j]))

98                     # phi[i, j] = invMultiQuadric(x[i,:], mu[j], sigmas[j]))

99                     phi[i, j] = multiQuadric(x[i,:], mu[j], sigmas[j])

100                     # phi[i, j] = gaussian(x[i,:], mu[j], sigmas[j]))

101                 if k % 1000 == 0:

102                     percent = true_divide(k, s)*100

103                     print(c, ': {:2.2f}%'.format(percent))

104             print(c, ': Done')

105      

106         # distributing the work between 4 workers

107         shared_array = Array(c_double, n * neurons)

108         phi = frombuffer(shared_array.get_obj())

109         phi = phi.reshape((n, neurons))

110

111         jobs = []

112         workers = []

113

114         p = n / C

115         m = n % C

116         for c in range(C):

117             jobs.append((c*p, (c+1)*p + (m if c == C-1 else 0)))

118             worker = Process(target = heavy_lifting, args = (c, phi))

119             workers.append(worker)

120             worker.start()

121

122         for worker in workers:

123             worker.join()

124

125         return phi

126

127     def _do_algebra(self, y):

128         phi = self.phi

129

130         w = lstsq(phi, y)[0]

131         os = dot(w, transpose(phi))

132         return w, os

133         # Saving to HDF5

134         os_h5 = os_handle.create_dataset('os', data = os)

135

136     def train(self, x, y):

137         self.n = x.shape[0]

138

139         ## Initialize HDF5 caches

140         prefix = self.prefix

141         postfix = str(self.n) + '-' + str(self.extra_neurons) + '.hdf5'

142         name_template = prefix + '-{}-' + postfix

143         phi_handle = self.phi_handle = File(name_template.format('phi'), 'w')

144         os_handle = self.w_handle = File(name_template.format('os'), 'w')

145         w_handle = self.w_handle = File(name_template.format('w'), 'w')

146         mu_handle = self.mu_handle = File(name_template.format('mu'), 'w')

147         sigma_handle = self.sigma_handle = File(name_template.format('sigma'), 'w')

148

149         ## Mu generation

150         mu = self.mu = self._generate_mu(x)

151         self.neurons = mu.shape[0]

152         print('({} neurons)'.format(self.neurons))

153         # Save to HDF5

154         mu_h5 = mu_handle.create_dataset('mu', data = mu)

155

156         ## Sigma calculation

157         print('Calculating Sigma...')

158         sigmas = self.sigmas = self._calculate_sigmas()

159         # Save to HDF5

160         sigmas_h5 = sigma_handle.create_dataset('sigmas', data = sigmas)

161         print('Done')

162

163         ## Phi calculation

164         print('Calculating Phi...')

165         phi = self.phi = self._calculate_phi(x)

166         print('Done')

167         # Saving to HDF5

168         print('Serializing...')

169         phi_h5 = phi_handle.create_dataset('phi', data = phi)

170         del phi

171         self.phi = phi_h5

172         print('Done')

173

174         ## Algebra

175         print('Doing final algebra...')

176         w, os = self.w, _ = self._do_algebra(y)

177         # Saving to HDF5

178         w_h5 = w_handle.create_dataset('w', data = w)

179         os_h5 = os_handle.create_dataset('os', data = os)

180

181         ## Calculate error

182         self._calculate_error(y)

183         print('Done')

184

185     def predict(self, test_data):

186         mu = self.mu = self.mu.value

187         sigmas = self.sigmas = self.sigmas.value

188         w = self.w = self.w.value

189

190         print('Calculating phi for test data...')

191         phi = self._calculate_phi(test_data)

192         os = dot(w, transpose(phi))

193         savetxt('iok3834.txt', os, delimiter='\n')

194         return os

195

196     @property

197     def summary(self):

198         return '\n'.join( \

199             ['-----------------',

200             'Training set size: {}'.format(self.n),

201             'Hidden layer size: {}'.format(self.neurons),

202             '-----------------',

203             'Absolute error   : {:02.2f}'.format(self.error),

204             'Relative error   : {:02.2f}%'.format(self.relative_error * 100)])

205

206

207 def predict(test_data):

208     mu = File('rbf-mu-212243-2400.hdf5', 'r')['mu'].value

209     sigmas = File('rbf-sigma-212243-2400.hdf5', 'r')['sigmas'].value

210     w = File('rbf-w-212243-2400.hdf5', 'r')['w'].value

211

212     n = test_data.shape[0]

213     neur = mu.shape[0]

214  

215     mu = transpose(mu)

216     mu.reshape((n, neur))

217

218     phi = zeros((n, neur))

219     for i in range(n):

220         for j in range(neur):

221             phi[i, j] = multiQuadric(test_data[i,:], mu[j], sigmas[j])

222

223     os = dot(w, transpose(phi))

224     savetxt('iok3834.txt', os, delimiter='\n')

225     return os

在分子模拟中，径向分布函数有什么意义

原子径向分布函数（Radial Distribution Function）：许多原子组成的系统中任取一原子为球心，求半径为r到r+dr的球壳内的平均原子数，再将每原子的结果进行平均，用函数4prr(r)dr表示（r(r）表示半径为r的球面上的平均原子密度），则RDF=4prr(r)称为原子径向分布函数。即任一原子周围，其他原子在沿径向的统计平均分布。图4-2为由x射线散射获得RDF描述非晶固体的原子分布的另两个函数为双体相关函数（双体几率函数）g(r）和约化径向分布函数G(r）约化径向分布函数：，r0为平均原子密度

实际上，要从理论上确定非晶态固体的径向分布函数，关键是获得函数r(r）。这可以通过原子状态同X射线间的干涉函数来确定。

分享文章：径向分布函数Python 径向分布函数图的峰数量如何确定
链接URL：http://pwwzsj.com/article/hjcccd.html