python机器学习数理基础_请利用np产生对应于每个队员唯一工位号的数组(例如数组取名gh中可保存编号分

资料补充

numpy开发者文档

numpy的一个很好的博客

numpy常用API

Python 数字

Matplotlib常用API

matplotlib教程

机器学习

就是机器完善模型的过程。

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()
1
2
3
4
5
6

#在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()
1
2
3
4
5
6

ANACONDA的安装

Anaconda 的安装教程（图文）

一个很有用的Anaconda博客

SVD（奇异值分解）的原理与应用

奇异值分解(SVD)详解及其应用

##一些基本操作

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])  #拿出第一列的值
1
2
3
4
5
6
7
8
9

产生随机数并且做出图像

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()

1
2
3
4
5
6
7
8

一千个样本的情况

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

##这个跟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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

画一个圆环

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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

---

补充：

Python随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

set_printoptions函数详细分析

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
1
2
3
4
5

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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
1
2
3
4
5
6
7
8
9
10
11

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
1
2
3
4
5
6
7
8
9
10

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

floatmode 控制“精度”选项的解释浮点类型。

画一个直方图

p=np.random.rand(10000)
np.set_printoptions(edgeitems=5000,suppress=True)
plt.hist(p,bins=20,color="g",edgecolor="k")
plt.show()
1
2
3
4

画一个高斯分布

##概念：正态分布（英语：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()
1
2
3
4
5
6
7
8
9
10

#生成3*4的矩阵#

d=np.random.rand(3,4)
print(d)
print(type(d))  #类型为数组
#############################一个神奇的操作#####################################
d[d<0.5]=0.5 #对于d中元素小于0.5的元素全部赋值为0.5 （这里涉及到列表推导式的简写）
1
2
3
4
5

panda模块的引入

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)
1
2
3
4
5
6
7
8
9

cv2的图片数据像素获取

import cv2
image=cv2.imread("11.jfif")
print(image)
print(type(image))
print(image.shape)
1
2
3
4
5

PIL的图片数据获取

from PIL import Image
a=Image.open("11.jfif")
print(a)
##获取a的像素值
b=np.array(a)
print(b,type(b))
1
2
3
4
5
6

1. 概率论基础

1.1 概率公式

1.2 贝叶斯公式

1.3 分布

两点分布

二项分布(伯努利分布)
方法一:

Taylor展开式

泊松分布

2. 统计量

2.1 期望

2.2 方差

2.2 协方差

2.2 相关系数

3. 大数定理

4. 中心极限定理

5. 最大似然估计

5.1 过拟合

##这里引用了一个博客：

#来画一个图像#

统计从一到一百的阶乘并且把它首个数字出现的个数进行统计

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()
1
2
3
4
5
6
7
8
9
10
11
12

运行结果：

##这里有个问题##就是递归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
2
3
4
5
6
7
8
9
10
11
12
13

本福特定律

基本概念

概念：本福特定律，也称为本福特法则，说明一堆从实际生活得出的数据中，以1为首位数字的数的出现概率约为总数的三成，接近直觉得出之期望值1/9的3倍。推广来说，越大的数，以它为首几位的数出现的概率就越低。它可用于检查各种数据是否有造假。

本福特定律（也称为第一位数法或本福特分布）是一种概率分布，许多统计学的（但不是全部）数据集的第一个数字符合。 例如

15435 是1
56    是5
9001  是9
199   是1
9     是9
12345
1
2
3
4
5
6

本福特定律通常可用作欺诈性数据的指标，并可协助审计会计数据。本福特的分布是一种不均匀的分布，较小的数字比较大的数字有更大的出现j可能。

数位分布概率

本福特分布图

本福特分布公式

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 大型企业的应付账款数据

分析显示，大型企业的应付几款的数据的数字第一位数字中有很大比例的1。经过仔细检查后发现，与上一个会计期间相比，还有更多的支付支票略高于1000美元。前一期的大部分支票金额低于100美元。

在一起财务调查中，负责的财务官随后受到质疑，他们回答称他们决定汇总金额以试图减少支票。低数字金额的合并是偏离本福特定律的常见解释，使财务官的解释变得合情合理。

经过进一步调查，据透露，该官员正在向他们创建的虚假壳公司写支票。

示例2：本福特的分析应用于组织的费用数据。

最初的本福特分析显示，数据的第一位数字中“非常大”的比例非常大。经过仔细检查，特定费用的许多条目达到45美元。发现费用对于运营组织至关重要，必须经常支付。调查了这笔特殊费用，然后被认为是合法的。

然后将Benford的分析应用于费用数据的副本，但省略了特定的频繁费用。发现排除该特定费用的数据与本福特的分布非常接近。

超越第一个数字推广本福特定律

通过查看第一个数字以外的数字，可以增强Benford的分析。

广义本福特的分布表

译者：本表的作用是表示分布规则还可以作用在不同的数位上。比如，0出现在第2位的概率是 11.97%，要高于平均值10%。

注意：由以上数据可以看出，在广义分布中，数字的出现概率要比第一个数字更加均匀。

一般分布公式

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的条件下的概率是不一样的；然而，这两者是有确定的关系,贝叶斯法则就是这种关系的陈述。

作为一个规范的原理，贝叶斯法则对于所有概率的解释是有效的；然而，频率主义者和贝叶斯主义者对于在应用中概率如何被赋值有着不同的看法：频率主义者根据随机事件发生的频率，或者总体样本里面的个数来赋值概率；贝叶斯主义者要根据未知的命题来赋值概率。一个结果就是，贝叶斯主义者有更多的机会使用贝叶斯法则。

贝叶斯法则是关于随机事件A和B的条件概率和边缘概率的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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: