赞
踩
就是机器完善模型的过程。
1.有监督的学习
2.无监督的学习
3.深度学习
信息=》Feature vector=》model=》ExpectedLavel
#一个划图像的代码
import numpy as np
import matplotlib.pyplot as plt
x=np.linspace(0.00001,3,100) #这个的意思开始的点为0.00001结束的点为3中间为100个点
y=x**x
plt.plot(x,y,"r-",linewidth=3)
plt.show()
#在0-1之间的图像
import numpy as np
import matplotlib.pyplot as plt
x=np.linspace(0,1,100)
y=x**x
plt.plot(x,y,"r-",linewidth=3)
plt.show()
##一些基本操作
import numpy as np
#产生一个从零到一的随机数
x=np.random.rand()
#产生一个列表 列表里面有十个列表,每个列表有从零到一的随机数
data=np.random.rand(10,2)
# #按行索引
# print(y,"\n索引值\n",y[[0,2]]) #拿出第一行和第三行数据
# #按列索引
# print(y,"\n索引值\n",y[:,0]) #拿出第一列的值
import numpy as np
import matplotlib.pyplot as plt
x=data[:,0]
y=data[:,1]
plt.plot(x,y,"go",linewidth=10)
print(x,y)
plt.show()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kx2BB49z-1613566915305)(C:\Users\mzy\AppData\Roaming\Typora\typora-user-images\image-20210216235008187.png)]
产生从负一到正一的数值
import numpy as np import matplotlib.pyplot as plt #产生一个从零到一的随机数 x=np.random.rand() #产生一个列表 列表里面有十个列表,每个列表有从零到一的随机数 data=2*np.random.rand(1000,2)-1 # #按行索引 # print(y,"\n索引值\n",y[[0,2]]) #拿出第一行和第三行数据 # #按列索引 # print(y,"\n索引值\n",y[:,0]) #拿出第一列的值 x=data[:,0] y=data[:,1] plt.plot(x,y,"go",linewidth=10) print(x,y) plt.show()
##这个跟c语言的rand()函数使用方法基本一样 可以按照rand()方法使用这个函数##
当索引值在一个单位圆内函数
import numpy as np import matplotlib.pyplot as plt #产生一个从零到一的随机数 #x=np.random.rand() #产生一个列表 列表里面有十个列表,每个列表有从零到一的随机数 data=2*np.random.rand(10,2)-1 # #按行索引 # print(y,"\n索引值\n",y[[0,2]]) #拿出第一行和第三行数据 # #按列索引 # print(y,"\n索引值\n",y[:,0]) #拿出第一列的值 x=data[:,0] y=data[:,1] print(x) print(y) #这句语句是index为一个numpy.ndarray的类(这个类可以当成列表来看) 就是列表中每个元素x的平方和y的平方的满足的返回true否则返回false #然后从这个列表中取每一个元素所对应的true和falset,true成立返回列表对应的原来的值 false不返回列表对饮的#值 index=x**2+y**2<1 print(index,type(index)) plt.plot(x[index],y[index],"go",linewidth=10) print(x,y) plt.show()
import numpy as np import matplotlib.pyplot as plt #产生一个从零到一的随机数 #x=np.random.rand() #产生一个列表 列表里面有十个列表,每个列表有从零到一的随机数 data=2*np.random.rand(10000,2)-1 # #按行索引 # print(y,"\n索引值\n",y[[0,2]]) #拿出第一行和第三行数据 # #按列索引 # print(y,"\n索引值\n",y[:,0]) #拿出第一列的值 x=data[:,0] y=data[:,1] print(x) print(y) #这句语句是index为一个numpy.ndarray的类(这个类可以当成列表来看) 就是列表中每个元素x的平方和y的平方的满足的返回true否则返回false #然后从这个列表中取每一个元素所对应的true和falset,true成立返回列表对应的原来的值 false不返回列表对饮的值 #index=x**2+y**2<1 & ~(x**2+y**2<0.25) #这个式子等价于index=np.logical_and(index,~hole) hole=x**2+y**2<0.25 #这里是np自己封装的一个逻辑和的式子 注意也可以用&表示和 |表示or “~“表示非 index=np.logical_and(index,~hole) print(index,type(index)) plt.plot(x[index],y[index],"go",linewidth=10) print(x,y) plt.show()
补充:
随机数可以用于数学,游戏,安全等领域中,还经常被嵌入到算法中,用以提高算法效率,并提高程序的安全性。
Python包含以下常用随机数函数:
函数 | 描述 |
---|---|
choice(seq) | 从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。 |
[randrange (start,] stop [,step]) | 从指定范围内,按指定基数递增的集合中获取一个随机数,基数默认值为 1 |
random() | 随机生成下一个实数,它在[0,1)范围内。 |
[seed(x]) | 改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed。 |
shuffle(lst) | 将序列的所有元素随机排序 |
uniform(x, y) | 随机生成下一个实数,它在[x,y]范围内。 |
numpy.set_printoptions()函数
set_printoptions(precision=None, threshold=None, edgeitems=None,
linewidth=None,suppress=None, nanstr=None,
infstr=None, formatter=None, sign=None,
floatmode=None, **kwarg)
1234
precision
浮点数组输出的精度位数,即小数点后位数(默认为8)。
## precision:控制陣列內容微幅點數時的列印精度(小數位數)
np.set_printoptions(precision=1)
print("NumPy set_printoptions(precision=1)\n", np.linspace(3, 5, 10))
print()
np.set_printoptions(precision=3)
print("NumPy set_printoptions(precision=3)\n", np.linspace(3, 5, 10))
Output:
NumPy set_printoptions(precision=1)
[3. 3.2 3.4 3.7 3.9 4.1 4.3 4.6 4.8 5. ]
NumPy set_printoptions(precision=3)
[3. 3.222 3.444 3.667 3.889 4.111 4.333 4.556 4.778 5. ]
1234567891011121314
threshold
元素门槛值。数组个数沒有超过设置的阈值,NumPy就会将Python將所有元素列印出來。
##threshold # 當要列印的陣列太大時,NumPy會自動以...代替一部分的內容,以減少篇幅! # 但是可以透過全域設定set_printoptions設定threshold(門檻值), # 元素數量少於或等於門檻值的陣列就會全部列印出來, # 相反地,元素數量高於門檻值,列印時就會省略部分內容。 # 陣列大小:20,門檻值20 => 陣列元素數量小於等於門檻值,應列印全部內容 np.set_printoptions(threshold=20) print("NumPy set_printoptions(threshold=20)\n", np.arange(20)) print() # 陣列大小:20,門檻值15 => 陣列元素數量大於門檻值,應省略部分內容 np.set_printoptions(threshold=15) print("NumPy set_printoptions(threshold=15)\n", np.arange(20)) Output: NumPy set_printoptions(threshold=20) [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19] NumPy set_printoptions(threshold=15) [ 0 1 2 3 4 ... 15 16 17 18 19] lmsdem = gdal_array.LoadFile(path) region = np.s_[1450:1500,1350:1400] z = lmsdem[region] np.set_printoptions(threshold=1000000) # print的元素个数小于1000000个,全部显示 print("="*30) Output: print(z) # 当threshold=1000000 时,实际打印的元素个数小于1000000,则打印结全部结果 [[1678 1718 1690 1660 1632 1641 1588 1491 1438 1411] [1670 1630 1580 1560 1530 1550 1541 1490 1413 1362] [1576 1559 1489 1461 1428 1435 1458 1426 1366 1323] [1482 1500 1422 1375 1342 1324 1353 1355 1314 1274] [1471 1457 1380 1304 1275 1257 1249 1278 1261 1250] [1379 1370 1312 1266 1265 1259 1246 1233 1243 1238] [1331 1298 1295 1338 1361 1336 1303 1251 1241 1237] [1363 1335 1372 1428 1458 1410 1363 1311 1270 1258] [1407 1381 1420 1485 1515 1485 1432 1367 1321 1321] [1427 1461 1476 1531 1574 1537 1476 1435 1395 1382]] ============================== print(z) # 当threshold=100 时,实际打印的元素个数大于100,则打印结果部分省略了 [[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]] 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849
edgeitems
当省略数组内元素内容时要显示的元素数量。
## edgeitems:當列印陣列時需要省略內容,edgeitems會決定要印出來的元素有幾個
np.set_printoptions(threshold=10, edgeitems=3)
print("NumPy set_printoptions(edgeitems=3)\n", np.arange(15))
print()
np.set_printoptions(threshold=10, edgeitems=5)
print("NumPy set_printoptions(edgeitems=5)\n", np.arange(15))
Output:
NumPy set_printoptions(edgeitems=3)
[ 0 1 2 ... 12 13 14]
NumPy set_printoptions(edgeitems=5)
[ 0 1 2 3 4 ... 10 11 12 13 14]
12345678910111213
linewidth
每一行要打印的元素个数
## linewidth np.set_printoptions(linewidth=10) print("NumPy set_printoptions(linewidth=10)\n", np.arange(15)) print() np.set_printoptions(linewidth=20) print("NumPy set_printoptions(linewidth=25)\n", np.arange(15)) Output: NumPy set_printoptions(linewidth=10) [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14] NumPy set_printoptions(linewidth=25) [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14] 123456789101112131415161718
suppress
是否要打印显示小数位
# suppress
np.set_printoptions(suppress=True)
print("NumPy set_printoptions(suppress=True)\n", np.arange(0, 1, 0.00
print()
np.set_printoptions(suppress=False)
print("NumPy set_printoptions(suppress=False)\n", np.arange(0, 1, 0.0
Output:
NumPy set_printoptions(suppress=True)
[0. 0. 0. ... 1. 1. 1.]
NumPy set_printoptions(suppress=False)
[0.e+00 1.e-05 2.e-05 ... 1.e+00 1.e+00 1.e+00]
12345678910111213
nanstr
当数组元素值出现NaN时所要显示的字符串
## nanstr
# 當陣列元素值出現not-a-number時要顯示的內容為何
np.set_printoptions(nanstr="Oops!")
a = np.array([np.nan, 1, np.nan], dtype=np.float16)
print("NumPy set_printoptions(nanstr=\"Oops!\")\n", a)
Output:
NumPy set_printoptions(nanstr="Oops!")
[Oops! 1. Oops!]
12345678910
infstr
数组元素值出現inf时所显示的字串
## infstr
# 當陣列元素值出現inf(無限大)時要顯示的內容為何
np.set_printoptions(infstr="∞")
a = np.array([np.inf, 8, -np.inf])
print("NumPy set_printoptions(infstr=\"∞\")\n", a)
Output:
NumPy set_printoptions(infstr="∞")
[ ∞ 8. -∞]
123456789
formatter
使用lambda函數客製列印陣列元素的格式
## formatter # 使用lambda函數客製列印陣列元素的格式 np.set_printoptions() # reset print options np.set_printoptions(formatter={'all': lambda x: 'i:' + str(x)}) print("NumPy set_printoptions(formatter={all: i:})\n", np.arange(0,5) print() # 這邊可以看出來,只設定了float的格式,是不會對int產生影響的 np.set_printoptions(formatter={'float_kind': lambda x: 'f:' + str(x) print("NumPy set_printoptions(formatter={float_kind: f:})\n", np.arange(0,5)) print("NumPy set_printoptions(formatter={float_kind: f:})\n", np.arange(0,5)) print() # 如果同時只想要客製float和int的格式,可以用逗號隔開設定值 np.set_printoptions(formatter={'int_kind': lambda x: 'i:' + str(x), print("NumPy set_printoptions({int_kind: i:, float_kind: f:})\n", np.arange(0,5)) print("NumPy set_printoptions({int_kind: i:, float_kind: f:})\n", np.arange(0,5)) Output: NumPy set_printoptions(formatter={all: i:}) [i:0 i:1 i:2 i:3 i:4] NumPy set_printoptions(formatter={float_kind: f:}) [0 1 2 3 4] NumPy set_printoptions(formatter={float_kind: f:}) [f:0.0 f:1.0 f:2.0 f:3.0 f:4.0] NumPy set_printoptions({int_kind: i:, float_kind: f:}) [i:0 i:1 i:2 i:3 i:4] NumPy set_printoptions({int_kind: i:, float_kind: f:}) [f:0.0 f:1.0 f:2.0 f:3.0 f:4.0] 1234567891011121314151617181920212223242526272829
sign
控制正负号
## sign # 當sign='+'時,就會連正數都會加上正號 np.set_printoptions(sign='+') a = np.array([9, 8, -6, -7], dtype=np.float16) print("NumPy set_printoptions(sign=\"+\")\n", a) print() # 當sign='-'時(預設值),就是只有數值<0時,才會加上負號 np.set_printoptions(sign='-') a = np.array([9, 8, -6, -7], dtype=np.float16) print("NumPy set_printoptions(sign=\"-\")\n", a) Output: NumPy set_printoptions(sign="+") [+9. +8. -6. -7.] NumPy set_printoptions(sign="-") [ 9. 8. -6. -7.] 12345678910111213141516
floatmode 控制“精度”选项的解释浮点类型。
p=np.random.rand(10000)
np.set_printoptions(edgeitems=5000,suppress=True)
plt.hist(p,bins=20,color="g",edgecolor="k")
plt.show()
##概念:正态分布(英语:normal distribution)又名高斯分布(英语:Gaussian distribution),是一个非常常见的连续概率分布。正态分布在统计学上十分重要,经常用在自然和社会科学来代表一个不明的随机变量。可以判断各种情况出现的概率,进而指导下一步的操作
随机变量是取值有多种可能并且取每个值都有一个概率的变量。它分为离散型和连续型两种,离散型随机变量的取值为有限个或者无限可列个(整数集是典型的无限可列),连续型随机变量的取值为无限不可列个(实数集是典型的无限不可列)。
n=10000
times=100
#初始化一个1*n的矩阵
z=np.zeros(n)
print(z)
for i in range(times):
z+=np.random.rand(n)
z/=times #z=z/times
plt.hist(z,bins=20,color="m",edgecolor="k")
plt.show()
#生成3*4的矩阵#
d=np.random.rand(3,4)
print(d)
print(type(d)) #类型为数组
#############################一个神奇的操作#####################################
d[d<0.5]=0.5 #对于d中元素小于0.5的元素全部赋值为0.5 (这里涉及到列表推导式的简写)
d=np.random.rand(3,4)
print(d)
print(type(d))
print("#"*50)
data=pd.DataFrame(data=d,columns=list("abcd")) #也可以用["a","b","c","d"] 代替,看源码是没有方法设置列标签的
print(data)
#拿出data里面b这一列的值
data["b"]
data.to_Csv("data.csv",index=False,header=True)
import cv2
image=cv2.imread("11.jfif")
print(image)
print(type(image))
print(image.shape)
from PIL import Image
a=Image.open("11.jfif")
print(a)
##获取a的像素值
b=np.array(a)
print(b,type(b))
两点分布
二项分布(伯努利分布)
方法一:
Taylor展开式
泊松分布
#来画一个图像#
def factorial(x):
if x==1:
return 1
return factorial(x-1)*x
list=[0]*9
for i in range(1,100):
fa=factorial(int(i))
num_first=int(str(fa)[0])
#print(fa)
list[num_first-1]=list[num_first-1]+1
plt.plot(list,"r-",linewidth=1)
plt.show()
运行结果:
##这里有个问题##就是递归1000次提示如下:
##进行改进代码:
def factorial(x):
factorial_num=1
for i in range(2,x+1):
factorial_num*=i
return factorial_num
list=[0]*9
for i in range(1,1000):
fa=factorial(int(i))
num_first=int(str(fa)[0])
#print(fa)
list[num_first-1]=list[num_first-1]+1
plt.plot(list,"r-",linewidth=1)
plt.show()
概念:本福特定律,也称为本福特法则,说明一堆从实际生活得出的数据中,以1为首位数字的数的出现概率约为总数的三成,接近直觉得出之期望值1/9的3倍。推广来说,越大的数,以它为首几位的数出现的概率就越低。它可用于检查各种数据是否有造假。
本福特定律(也称为第一位数法或本福特分布)是一种概率分布,许多统计学的(但不是全部)数据集的第一个数字符合。 例如
15435 是1
56 是5
9001 是9
199 是1
9 是9
12345
本福特定律通常可用作欺诈性数据的指标,并可协助审计会计数据。本福特的分布是一种不均匀的分布,较小的数字比较大的数字有更大的出现j可能。
第1位数字 | 出现概率 |
---|---|
1 | 0.301 |
2 | 0.176 |
3 | 0.125 |
4 | 0.097 |
5 | 0.079 |
6 | 0.067 |
7 | 0.058 |
8 | 0.051 |
9 | 0.046 |
P ( d ) = l o g 10 ( d + 1 ) − l o g 10 d = l o g 10 ( 1 + 1 d ) P(d) = log_{10}(d + 1)-log_{10}d = log_{10}(1 + \frac{1}{d})P(d)=log10(d+1)−log10d=log10(1+d1)
在大部分情况下,本福特定律可以适用于具有以下特征的数据:
虽然有以上的限制,但实际上在会计中,符合上述特征的数据非常普遍。
应收账款,应付账款,销售和费用数据均基于两种类型的变量相乘的值,即价格和数量。 单独,价格和数量不太可能符合本福特定律,但很可能会成倍增加。 这种会计数据也可能是正确的。 大公司的交易级会计数据几乎总是会有大量的观察结果。
如果某些会计数据预计符合本福特定律但不符合,则并不一定意味着数据是欺诈性的。 然而,这将为进一步调查提供充分的理由。
以下是如何对会计数据执行本福特分布分析的一些示例。
分析显示,大型企业的应付几款的数据的数字第一位数字中有很大比例的1
。经过仔细检查后发现,与上一个会计期间相比,还有更多的支付支票略高于1000美元。前一期的大部分支票金额低于100美元。
在一起财务调查中,负责的财务官随后受到质疑,他们回答称他们决定汇总金额以试图减少支票。低数字金额的合并是偏离本福特定律的常见解释,使财务官的解释变得合情合理。
经过进一步调查,据透露,该官员正在向他们创建的虚假壳公司写支票。
最初的本福特分析显示,数据的第一位数字中“非常大”的比例非常大。经过仔细检查,特定费用的许多条目达到45美元。发现费用对于运营组织至关重要,必须经常支付。调查了这笔特殊费用,然后被认为是合法的。
然后将Benford的分析应用于费用数据的副本,但省略了特定的频繁费用。发现排除该特定费用的数据与本福特的分布非常接近。
通过查看第一个数字以外的数字,可以增强Benford的分析。
译者:本表的作用是表示分布规则还可以作用在不同的数位上。比如,0出现在第2位的概率是 11.97%,要高于平均值10%。
数位 | 第1位 | 第2位 | 第3位 | 第4位 | 第5位 |
---|---|---|---|---|---|
0 | NA | 0.11968 | 0.10178 | 0.10018 | 0.10002 |
1 | 0.30103 | 0.11389 | 0.10138 | 0.10014 | 0.10001 |
2 | 0.17609 | 0.10882 | 0.10097 | 0.10010 | 0.10001 |
3 | 0.12494 | 0.10433 | 0.10057 | 0.10006 | 0.10001 |
4 | 0.09691 | 0.10031 | 0.10018 | 0.10002 | 0.10000 |
5 | 0.07918 | 0.09668 | 0.09979 | 0.09998 | 0.10000 |
6 | 0.06695 | 0.09337 | 0.09940 | 0.09994 | 0.09999 |
7 | 0.05799 | 0.09035 | 0.09902 | 0.09990 | 0.09999 |
8 | 0.05115 | 0.08757 | 0.09864 | 0.09986 | 0.09999 |
9 | 0.04576 | 0.08500 | 0.09827 | 0.09982 | 0.09998 |
注意:由以上数据可以看出,在广义分布中,数字的出现概率要比第一个数字更加均匀。
P ( d ) = ∑ k = 1 0 n − 2 1 0 n − 1 − 1 l o g 10 ( 1 + 1 10 k + d ) P(d)=\sum_{k=10{n-2}}{10^{n-1} - 1}log_{10}(1 + \frac{1}{10k+d})P(d)=k=10n−2∑10n−1−1log10(1+10k+d1)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jYoZbw4z-1613795005797)(https://bkimg.cdn.bcebos.com/formula/e30d3c07ebac8545498b8acac60f34e8.svg)]
定理
若事件A1,A2,…构成一个完备事件组且都有正概率,则对任意一个事件B,有如下公式成立:
P(B)=P(BA1)+P(BA2)+…+P(BAn)=P(B|A1)P(A1) + P(B|A2)P(A2) + … + P(B|An)P(An).
此公式即为全概率公式。
特别地,对于任意两随机事件A和B,有如下成立:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bV8Df0MD-1613795005803)(https://bkimg.cdn.bcebos.com/formula/35b10c674e416e7e862267aeea2b312c.svg)]
其中A和Ac为对立事件。
所谓贝叶斯公式,是指当分析样本大到接近总体数时,样本中事件发生的概率将接近于总体中事件发生的概率。但行为经济学家发现,人们在决策过程中往往并不遵循贝叶斯规律,而是给予最近发生的事件和最新的经验以更多的权值,在决策和做出判断时过分看重近期的事件。面对复杂而笼统的问题,人们往往走捷径,依据可能性而非根据概率来决策。这种对经典模型的系统性偏离称为“偏差”。由于心理偏差的存在,投资者在决策判断时并非绝对理性,会行为偏差,进而影响资本市场上价格的变动。但长期以来,由于缺乏有力的替代工具,经济学家不得不在分析中坚持贝叶斯法则。 [1]
通常,事件A在事件B(发生)的条件下的概率,与事件B在事件A的条件下的概率是不一样的;然而,这两者是有确定的关系,贝叶斯法则就是这种关系的陈述。
作为一个规范的原理,贝叶斯法则对于所有概率的解释是有效的;然而,频率主义者和贝叶斯主义者对于在应用中概率如何被赋值有着不同的看法:频率主义者根据随机事件发生的频率,或者总体样本里面的个数来赋值概率;贝叶斯主义者要根据未知的命题来赋值概率。一个结果就是,贝叶斯主义者有更多的机会使用贝叶斯法则。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wwCjXjom-1613795005806)(https://bkimg.cdn.bcebos.com/formula/b31aa378530e552127512be06a522b70.svg)]
其中P(A|B)是在B发生的情况下A发生的可能性。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vDw6hpO8-1613795005807)(https://bkimg.cdn.bcebos.com/formula/3b5568f4510de6601c831270ef37af8e.svg)]
为完备事件组,即
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2H0Asm18-1613795005809)(https://bkimg.cdn.bcebos.com/formula/47b44530235acff6998900774c85683d.svg)]
在贝叶斯法则中,每个名词都有约定俗成的名称:
Pr(A)是A的先验概率或边缘概率。之所以称为"先验"是因为它不考虑任何B方面的因素。
Pr(A|B)是已知B发生后A的条件概率,也由于得自B的取值而被称作A的后验概率。
Pr(B|A)是已知A发生后B的条件概率,也由于得自A的取值而被称作B的后验概率。
Pr(B)是B的先验概率或边缘概率,也作标准化常量(normalized constant)。
按这些术语,Bayes法则可表述为:
后验概率 = (似然度 * 先验概率)/标准化常量 也就是说,后验概率与先验概率和似然度的乘积成正比。
另外,比例Pr(B|A)/Pr(B)也有时被称作标准似然度(standardised likelihood),Bayes法则可表述为:
后验概率 = 标准似然度 * 先验概率。 [1]
对于变量有二个以上的情况,贝式定理亦成立。例如:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mmexsINg-1613795005810)(https://bkimg.cdn.bcebos.com/formula/7ed711ff66ae708e02b1ba224862a7be.svg)]
这个式子可以由套用多次二个变量的贝氏定理及条件机率的定义导出。
伯努利分布指的是对于随机变量X有, 参数为p(0<p<1),如果它分别以概率p和1-p取1和0为值。EX= p,DX=p(1-p)。伯努利试验成功的次数服从伯努利分布,参数p是试验成功的概率。伯努利分布是一个离散型机率分布,是N=1时二项分布的特殊情况,为纪念瑞士科学家詹姆斯·伯努利(Jacob Bernoulli 或James Bernoulli)而命名。 [1]
一个非常简单的试验是只有两个可能结果的试验,比如正面或反面,成功或失败,有缺陷或没有缺陷,病人康复或未康复。为方便起见,记这两个可能的结果为0和1,下面的定义就是建立在这类试验基础之上的。 [2]
如果随机变量X只取0和1两个值,并且相应的概率为:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nMmLreFw-1613795005811)(https://bkimg.cdn.bcebos.com/formula/94dbb6dd3fcf103a46c81205a8e46d36.svg)]
则称随机变量X服从参数为p的伯努利分布,若令q=1一p,则X的概率函数可写
为:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zAb1p6FT-1613795005812)(https://bkimg.cdn.bcebos.com/formula/6964206b823dda83d13fd409cb9075e5.svg)]
要证明该概率函数
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ymt6b4Q9-1613795005813)(https://bkimg.cdn.bcebos.com/formula/b52ed39c539199d5f4d4c046e1ffaef8.svg)]
确实是公式所定义的伯努利分布,只要注意到
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pQHidO1m-1613795005813)(https://bkimg.cdn.bcebos.com/formula/09841e3efde3f52360fcf239d100e590.svg)]
,就很容易得证。 [2]
在n次独立重复的伯努利试验中,设每次试验中事件A发生的概率为p。用X表示n重伯努利试验中事件A发生的次数,则X的可能取值为0,1,…,n,且对每一个k(0≤k≤n),事件{X=k}即为“n次试验中事件A恰好发生k次”,随机变量X的离散概率分布即为二项分布(Binomial Distribution)。 [1]
在概率论和统计学中,二项分布是n个独立的成功/失败试验中成功的次数的离散概率分布,其中每次试验的成功概率为p。这样的单次成功/失败试验又称为伯努利试验。实际上,当n=1时,二项分布就是伯努利分布。 [2]
一般地,如果随机变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WEBlY8C3-1613795005815)(https://bkimg.cdn.bcebos.com/formula/9f7d1d2e6f98698b18cf0939756901ac.svg)]
服从参数为
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gveu9pm1-1613795005816)(https://bkimg.cdn.bcebos.com/formula/561ce0d0c21ba2a257cc72a28956377b.svg)]
和
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-No859st9-1613795005816)(https://bkimg.cdn.bcebos.com/formula/d8c7c06e950362e1dc4b91f25c37f38a.svg)]
的二项分布,我们记为
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mNLsMjmy-1613795005817)(https://bkimg.cdn.bcebos.com/formula/bcffdbb8feb6becc504ad8dfffbce9a4.svg)]
或
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bJBVkPFO-1613795005818)(https://bkimg.cdn.bcebos.com/formula/cc0fb2cf4503f27b5f06d2d3e83156e6.svg)]
。n次试验中正好得到k次成功的概率由概率质量函数给出: [2]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qbRgzerX-1613795005819)(https://bkimg.cdn.bcebos.com/formula/810fe5db77e112b4230ce3c0e156a589.svg)]
式中k=0,1,2,…,n,
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NSykV3QZ-1613795005820)(https://bkimg.cdn.bcebos.com/formula/78f08bad28624c78ef7a97616854f5fa.svg)]
是二项式系数(这就是二项分布名称的由来),又记为
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w8yZnGNM-1613795005821)(https://bkimg.cdn.bcebos.com/formula/5a850a52b9d9789158a7a3a6869264dc.svg)]
或者
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MGoRhYMC-1613795005822)(https://bkimg.cdn.bcebos.com/formula/487193a48a755ae068b269d85c610206.svg)]
。 该公式可以用以下方法理解:我们希望有k次成功§和n−k次失败(1 −p)。并且,k次成功可以在n次试验的任何地方出现,而把k次成功分布在n次试验中共有
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qq3woFtG-1613795005822)(https://bkimg.cdn.bcebos.com/formula/5a850a52b9d9789158a7a3a6869264dc.svg)]
个不同的方法。 [2]
[编辑](javascript:
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。