molittle molittle 2025-07-25T14:41:49.255Z http://git.molittle.site/ molittle Hexo http://git.molittle.site/posts/0.html 2025-06-10T07:47:45.655Z 2025-07-25T14:41:49.255Z

title: 聚类算法
tags:

  • AI
    id: ‘360’
    categories:
    • program
    • 机器学习
      abbrlink: 35f08535
      mathjax: true
      date: 2025-06-09 10:49:32

聚类算法

1、聚类介绍

1.1、聚类作用

  • 知识发现 发现事物之间的潜在关系

  • 异常值检测

  • 特征提取 数据压缩的例子

1.2、有监督与无监督学习

有监督：

  • 给定训练集 X 和 标签Y

  • 选择模型

    • 学习（目标函数的最优化）
    • 生成模型（本质上是一组参数、方程）

根据生成的一组参数进行预测分类等任务

无监督：

  • 拿到的数据只有X ，没有标签，只能根据X的相似程度做一些事情。

  • Clustering 聚类

    • 对于大量未标注的数据集，按照内在相似性来分为多个类别（簇） 目标：类别内相似度大，类别间相似小。
    • 也可以用来改变数据的维度，可以将聚类结果作为一个维度添加到训练数据中。

  • 降维算法，数据特征变少

1.3、聚类算法

1.4、相似度

1.5、数据间的相似度

  • 每一条数据都可以理解为多维空间中的一个点。

  • 可以根据点和点之间的距离来评价数据间的相似度

  • 近朱者赤近墨者黑！

欧氏距离：

  • 二维空间：

d=(x1−x2)2+(y1−y2)2d=\sqrt{(x_1 - x_2)^2 + (y_1 - y_2)^2}

  • 三维空间：

d=(x1−x2)2+(y1−y2)2+(z1−z2)2d=\sqrt{(x_1 - x_2)^2 + (y_1 - y_2)^2 + (z_1 - z_2)^2}

  • 闵可夫斯基距离

d(X,Y)=∣x1−y1∣p+∣x2−y2∣p+…+∣xn−yn∣ppd(X,Y) = \sqrt[p]{|x_1 - y_1|^p + |x_2 - y_2|^p + … + |x_n - y_n|^p}

  • P = 1 曼哈顿距离

    • d(X,Y)=∣x1−y1∣+∣x2−y2∣+…+∣xn−yn∣d(X,Y) = |x_1 - y_1| + |x_2 - y_2| + … + |x_n - y_n|
    • 在二维空间中可以看出，这种距离是计算两点之间的直角边距离，相当于城市中出租汽车沿城市街道拐直角前进而不能走两点连接间的最短距离。

  • P = 2 欧氏距离，就是两点之间的直线距离（以下简称欧氏距离）

  • P = 无穷，切比雪夫距离 ，哪个维度差值最大就是那个差值作为距离。

1.6、余弦距离

将数据看做空间中的点的时候，评价远近可以用欧氏距离或者余弦距离。

计算过程如下：

  • 将数据映射为高维空间中的点（向量）
  • 计算向量间的余弦值
  • 取值范围[-1,+1] 越趋近于1代表越相似，越趋近于-1代表方向相反，0代表正交

cosθ=a⋅b∣∣a∣∣2∣∣b∣∣2cos\theta = \frac{a \cdot b}{||a||_2||b||_2}

cosθ=x1x2+y1y2x12+y12×x22+y22cos\theta = \frac{x_1x_2 + y_1y_2}{\sqrt{x_1^2 + y_1^2} \times \sqrt{x_2^2 + y_2^2}}

  • 余弦相似度可以评价文章的相似度，从而实现对文章，进行分类。

2、Kmeans

2.1、聚类原理

  • 将N个样本映射到K个簇中

  • 每个簇至少有一个样本

基本思路：

  • 先给定K个划分，迭代样本与簇的隶属关系，每次都比前一次好一些

  • 迭代若干次就能得到比较好的结果

2.2、Kmeans算法原理

算法步骤：

  • 选择K个初始的簇中心

    • 怎么选？

  • 逐个计算每个样本到簇中心的距离，将样本归属到距离最小的那个簇中心的簇中

  • 每个簇内部计算平均值，更新簇中心

  • 开始迭代

聚类过程如下：

2.3、KMeans优缺点

  • 优点：

    • 简单，效果不错

  • 缺点

    • 对异常值敏感
    • 对初始值敏感
    • 对某些分布聚类效果不好

2.4、Kmeans损失函数

∑i=0nmin⁡μj∈C(∣∣xi−μj∣∣2)\sum\limits_{i=0}^{n}\underset{\mu_j \in C}\min(||x_i - \mu_j||^2)

  • 其中μj=1∣Cj∣∑x∈Cjx\mu_j = \frac{1}{|C_j|}\sum\limits_{x \in C_j}x是簇的均值向量，或者说是质心。

  • 其中∣∣xi−μj∣∣2||x_i - \mu_j||^2代表每个样本点到均值点的距离（其实也是范数）。

2.5、Kmeans执行过程

2.6、Kmeans初步使用

亚洲国家队划分：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
import pandas as pd

# 需要将亚洲国家队，分成三个类别
# 只有历年的统计数据，没有目标值（类别，等级）
data = pd.read_csv('./AsiaFootball.txt')
data

# 执行多次，分类结果会有所不同
kmeans = KMeans(n_clusters=3)
# 无监督，只需要给数据X就可以
kmeans.fit(data.iloc[:,1:])
y_ = kmeans.predict(data.iloc[:,1:])# 聚类算法预测、划分的类别
c = data['国家'].values
for i in range(3):
    cond = y_ == i#索引条件
    print('类别是%d的国家有：'%(i),c[cond])
1
2
3
类别是0的国家有： ['中国' '伊拉克' '卡塔尔' '阿联酋' '泰国' '越南' '阿曼' '印尼']
类别是1的国家有： ['伊朗' '沙特' '乌兹别克斯坦' '巴林' '朝鲜']
类别是2的国家有： ['日本' '韩国']

数据可视化：

1
2
3
4
5
6
7
8
9
10
11
12
13
plt.rcParams['font.family'] = 'STKaiti'
fig = plt.figure(figsize=(12,9))

ax = plt.axes(projection = '3d')

ax.scatter(data.iloc[:,1],data.iloc[:,2],data.iloc[:,3],c = y_,s = 100)

ax.set_xlabel('2006年世界杯',fontsize = 18)
ax.set_ylabel('2010年世界杯',fontsize = 18)
ax.set_zlabel('2007亚洲杯',fontsize = 18)

# 调整视图角度
ax.view_init(elev = 20,azim = -60)

2.7、Kmeans聚类算法K值选择

轮廓系数：

针对某个样本的轮廓系数s为：$ s= \frac{b - a}{max(a, b)}$

  • a：某个样本与其所在簇内其他样本的平均距离
  • b：某个样本与其他簇样本的平均距离

聚类总的轮廓系数SC为：SC=1N∑i=1NsiSC = \frac{1}{N}\sum\limits_{i = 1}^Ns_i，所有样本的sis_i的均值称为聚类结果的轮廓系数，是该聚类是否合理、有效的度量。

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

import numpy as np
from sklearn import datasets
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
# 聚类：轮廓系数，对聚类的评价指标，对应数学公式
from sklearn.metrics import silhouette_score

# 创建数据
# 假数据，数据X划分成3类
X,y = datasets.make_blobs(centers=3)
plt.scatter(X[:,0],X[:,1],c = y)

# 指定不同的k，寻找最佳聚类类别数目
# 可以画图，一目了然，数据简单，属性只有两个，所以可以画图
# 属性多，无法可视化，评价指标
# 轮廓系数
plt.rcParams['font.sans-serif'] = 'KaiTi'
plt.rcParams['font.size'] = 18
plt.rcParams['axes.unicode_minus'] = False
score = []
for i in range(2,7):
    kmeans = KMeans(n_clusters=i)
    kmeans.fit(X)
    y_ = kmeans.predict(X)# 预测类别 == 标签
#     plt.scatter(X[:,0],X[:,1],c = y_)
    score.append(silhouette_score(X,y_))
#     print('当聚类类别是6的时候，评价指标轮廓系数： ',silhouette_score(X,y_))
plt.plot(range(2,7),score)
plt.xlabel('K值')
plt.ylabel('轮廓系数',c = 'red')
# 结论：，当k值是3的时候，轮廓系数最大，这个时候，说明划分效果最好！

效果图如下：（注意数据随机生成，数据展示的图片效果不是固定的~）

调整兰德系数：

公式了解一下即可：

RI=a+bC2nsamples\text{RI} = \frac{a + b}{C_2^{n_{samples}}}

用C表示实际的类别划分（y_true），K表示聚类结果（y_pred）。

定义a 为在C中被划分为同一类，在K中被划分为同一簇的实例对数量。

定义b为在C中被划分为不同类别，在K中被划分为不同簇的实例对数量。

兰德系数范围是[0,1]

调整兰德系数为：

ARI=RI−E[RI]max⁡(RI)−E[RI]\text{ARI} = \frac{\text{RI} - E[\text{RI}]}{\max(\text{RI}) - E[\text{RI}]}

范围为[-1,1]

1
2
3
4
5
6
7
8
9
10
11
from sklearn.metrics import adjusted_rand_score# 调整兰德系数
score = []
for i in range(2,7):
    kmeans = KMeans(n_clusters=i)
    kmeans.fit(X)
    y_ = kmeans.predict(X)# 预测类别 == 标签
    score.append(adjusted_rand_score(y,y_))
plt.plot(range(2,7),score)
plt.xlabel('K值')
plt.ylabel('调整兰德系数',c = 'red')
# 结论：，当k值是3的时候，轮廓系数最大，这个时候，说明划分效果最好！

2.8、Kmeans图像压缩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import matplotlib.pyplot as plt # plt 用于显示图片
from sklearn.cluster import KMeans
import numpy as np
plt.figure(figsize=(8,4))

# 加载图片显示原图
pixel = plt.imread('11-bird.png')
plt.subplot(1,2,1)
plt.imshow(pixel)

# 聚类运算，压缩图片
pixel = pixel.reshape((128*128 , 3))
kmeans = KMeans(n_clusters=8).fit(pixel)

# 聚类结果合成新图片
newPixel = kmeans.cluster_centers_[kmeans.labels_].reshape(128,128,3)
plt.subplot(1,2,2)
plt.imshow(newPixel)

3、DBSCAN

3.1、算法介绍

DBSCAN（Density-Based Spatial Clustering of Applications with Noise，具有噪声的基于密度的聚类方法）是一种基于密度的空间聚类算法。 该算法将具有足够密度的区域划分为簇，并在具有噪声的空间数据库中发现任意形状的簇，它将簇定义为密度相连的点的最大集合。

下面这些点是分布在样本空间的众多样本，现在我们的目标是把这些在样本空间中距离相近的聚成一类。我们发现A点附近的点密度较大，红色的圆圈根据一定的规则在这里滚啊滚，最终收纳了A附近的5个点，标记为红色也就是定为同一个簇。其它没有被收纳的根据一样的规则成簇。（形象来说，我们可以认为这是系统在众多样本点中随机选中一个，围绕这个被选中的样本点画一个圆，规定这个圆的半径以及圆内最少包含的样本点，如果在指定半径内有足够多的样本点在内，那么这个圆圈的圆心就转移到这个内部样本点，继续去圈附近其它的样本点，类似传销一样，继续去发展下线。等到这个滚来滚去的圈发现所圈住的样本点数量少于预先指定的值，就停止了。那么我们称最开始那个点为核心点，如A，停下来的那个点为边界点，如B、C，没得滚的那个点为离群点，如N）。

基于密度这点有什么好处呢，我们知道Kmeans聚类算法只能处理球形的簇，也就是一个聚成实心的团（这是因为算法本身计算平均距离的局限）。但往往现实中还会有各种形状，比如下面两张图，环形和不规则形，这个时候，那些传统的聚类算法显然就悲剧了。于是就思考，样本密度大的成一类呗。这就是DBSCAN聚类算法。

3.2、DBSCAN算法原理

网站动画解析

3.3、DBSCAN参数解析

参数一eps：

DBSCAN算法参数，即我们的eps邻域的距离阈值，和样本距离超过eps的样本点不在eps邻域内。默认值是0.5.一般需要通过在多组值里面选择一个合适的阈值。eps过大，则更多的点会落在核心对象的eps邻域，此时我们的类别数可能会减少， 本来不应该是一类的样本也会被划为一类。反之则类别数可能会增大，本来是一类的样本却被划分开。

参数二min_samples：

DBSCAN算法参数，即样本点要成为核心对象所需要的eps邻域的样本数阈值。默认值是5。一般需要通过在多组值里面选择一个合适的阈值。通常和eps一起调参。在eps一定的情况下，min_samples过大，则核心对象会过少，此时簇内部分本来是一类的样本可能会被标为噪音点，类别数也会变多。反之min_samples过小的话，则会产生大量的核心对象，可能会导致类别数过少。

参数与三metrics：

3.4、DBSCAN使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np
from sklearn import datasets
from sklearn.cluster import KMeans,DBSCAN
import matplotlib.pyplot as plt

# y中是两类：0,1
X,y = datasets.make_circles(n_samples=1000,noise=0.05,factor = 0.5)
# centers = [(1.5,1.5)] 元组，代表着，中心点的坐标值
# y1一类：0 + 2
X1,y1 = datasets.make_blobs(n_samples=500,n_features=2,centers=[(1.5,1.5)],cluster_std=0.2)

# 将circle和散点进行了数据合并
X = np.concatenate([X,X1])
y = np.concatenate([y,y1 + 2])
plt.scatter(X[:,0],X[:,1],c = y)

1
2
3
4
5
# 根据距离，划分‘势力范围’
kmeans = KMeans(3)
kmeans.fit(X)
y_ = kmeans.labels_
plt.scatter(X[:,0],X[:,1],c = y_)

1
2
3
4
dbscan = DBSCAN(eps = 0.2,min_samples=3)
dbscan.fit(X)
y_ = dbscan.labels_
plt.scatter(X[:,0],X[:,1],c = y_)

4、分层聚类

4.1、算法介绍

分层聚类输出层次结构，这种结构比平面聚类返回的非结构化聚类集更具信息性。

分层聚类法（hierarchical cluster method）一译“系统聚类法”。聚类分析的一种方法。其做法是开始时把每个样品作为一类，然后把最靠近的样品（即距离最小的群品）首先聚为小类，再将已聚合的小类按其类间距离再合并，不断继续下去，最后把一切子类都聚合到一个大类。

一般来说，当考虑聚类效率时，我们选择平面聚类，当平面聚类的潜在问题（不够结构化，预定数量的聚类，非确定性）成为关注点时，我们选择层次聚类。 此外，许多研究人员认为，层次聚类比平面聚类产生更好的聚类。

4.2、算法原理

层次聚类(Hierarchical Clustering)是聚类算法的一种，通过计算不同类别数据点间的相似度来创建一棵有层次的嵌套聚类树。在聚类树中，不同类别的原始数据点是树的最低层，树的顶层是一个聚类的根节点。创建聚类树有自下而上合并和自上而下分裂两种方法。

我们着重看一下自底向上的合并算法：

两个组合数据点间的距离:

  • Single Linkage
    • 方法是将两个组合数据点中距离最近的两个数据点间的距离作为这两个组合数据点的距离。这种方法容易受到极端值的影响。两个很相似的组合数据点可能由于其中的某个极端的数据点距离较近而组合在一起。
  • Complete Linkage
    • complete Linkage的计算方法与Single Linkage相反，将两个组合数据点中距离最远的两个数据点间的距离作为这两个组合数据点的距离。Complete Linkage的问题也与Single Linkage相反，两个不相似的组合数据点可能由于其中的极端值距离较远而无法组合在一起。
  • Average Linkage
    • Average Linkage的计算方法是计算两个组合数据点中的每个数据点与其他所有数据点的距离。将所有距离的均值作为两个组合数据点间的距离。这种方法计算量比较大，但结果比前两种方法更合理。
    • 我们使用Average Linkage计算组合数据点间的距离。下面是计算组合数据点(A,F)到(B,C)的距离，这里分别计算了(A,F)和(B,C)两两间距离的均值。

4.3、参数介绍

  • n_clusters

    划分类别数目

  • linkage

    度量两个子类的相似度时所依据的距离

    • Single Linkage：将两个数据点集中距离最近的两个数据点间的距离作为这两个点集的距离。
    • Complete Linkage：将两个点集中距离最远的两个数据点间的距离作为这两个点集的距离。
      上述两种方法容易受到极端值的影响，计算大样本集效率较高。
    • Average Linkage：计算两个点集中的每个数据点与其他所有数据点的距离。将所有距离的均值作为两个点集间的距离。这种方法计算量比较大，不过这种度量方法更合理
    • Ward：最小化簇内方差。

  • connectivity

    连接性约束，作用：只有相邻的簇才能合并在一起，进行聚类！

4.4、算法案例

导包

1
2
3
4
5
import numpy as np
import matplotlib.pyplot as plt
import mpl_toolkits.mplot3d.axes3d as p3
from sklearn.cluster import AgglomerativeClustering
from sklearn.datasets import make_swiss_roll

创建数据

1
2
3
4
5
X,y = datasets.make_swiss_roll(n_samples=1500,noise = 0.05)
fig = plt.figure(figsize=(12,9))
a3 = fig.add_subplot(projection = '3d')
a3.scatter(X[:,0],X[:,1],X[:,2],c = y)
a3.view_init(10,-80)

Kmeans聚类效果

1
2
3
4
5
6
7
8
# Kmeans只负责分类，随机性，类别是数字几，不固定
clf = KMeans(n_clusters=6)
clf.fit(X)
y_ = clf.labels_
fig = plt.figure(figsize=(12,9))
a3 = plt.subplot(projection = '3d')
a3.scatter(X[:,0],X[:,1],X[:,2],c = y_)
a3.view_init(10,-80)

分层聚类

1
2
3
4
5
6
7
agg = AgglomerativeClustering(n_clusters=6,linkage='ward')# 最近的距离，作为标准，
agg.fit(X)
y_ = agg.labels_
fig = plt.figure(figsize=(12,9))
a3 = plt.subplot(projection = '3d')
a3.scatter(X[:,0],X[:,1],X[:,2],c = y_)
a3.view_init(10,-80)

对于这种非欧几何的数据下，可见如果没有设置连接性约束，将会忽视其数据本身的结构，强制在欧式空间下聚类，于是很容易形成了上图这种跨越流形的不同褶皱。

分层聚类改进（连接性约束，对局部结构进行约束）

1
2
3
4
5
6
7
8
9
10
from sklearn.neighbors import kneighbors_graph# graph图形的意思
# 邻居数量变少，认为，条件宽松
conn = kneighbors_graph(X,n_neighbors=10) #采用邻居，进行约束
agg = AgglomerativeClustering(n_clusters=6,connectivity=conn,linkage='ward')# 最近的距离，作为标准，
agg.fit(X)
y_ = agg.labels_
fig = plt.figure(figsize=(12,9))
a3 = fig.add_subplot(projection = '3d')
a3.scatter(X[:,0],X[:,1],X[:,2],c = y_)
a3.view_init(10,-80)

]]> <hr> <p>title: 聚类算法<br> tags:</p> <ul> <li>AI<br> id: ‘360’<br> categories:</li> <li> <ul> <li>program</li> <li>机器学习<br> abbrlink: 35f08535< 功能测试 http://git.molittle.site/posts/d87f7e0c.html 2025-06-10T06:09:51.000Z 2025-07-25T14:57:04.654Z 666


]]> <p><img src="./test/11-bird.png" alt="666"><br> <img src="../images/1-%E8%81%9A%E7%B1%BB.png" alt=""><br> <img src="../img/bot2font.svg" alt 1-KNN http://git.molittle.site/posts/8b6a7df5.html 2025-06-10T05:49:32.000Z 2025-07-25T14:42:56.788Z KNN

  • k nearest neighbors

  • k近邻算法

  • k表示个数

    • 你有几个好朋友？
    • 你有几个邻居？
    • 你有几个女朋友？

  • 邻居是什么样性质，类别，影响你，之所以成为了邻居，必然共性

    • 比如你的邻居是马云、马化腾、李嘉诚，你必然也是亿万富翁
    • 比如你的邻居是葛优、张国立、成龙，比必然也是明星
    • 比如你的邻居是习大大、毛爷爷、李克强总理，比必然也是为人民服务的公务人员

  • 根据这个特征，来对事物进行分类

  • 邻居，距离比较近

    • 问题，请问Xu这个点属于哪个类别呢？
    • 三个类别：红色、绿色、蓝色
    • 找Xu这个点的最近的5个邻居（5 == k，调大跳小）
    • 从图中直观看到，4个最近邻居是红色，1个最近的邻居是绿色
    • 人多力量大，投票决定，民主。4 > 1
    • 对人而言，投票
    • 对计算机而言，统计
    • 0.8 > 0.2
    • 从票数或者从概率上分类的话，得到这样的结论
    • Xu属于红色的类别！
    • KNN根据远近，进行类别划分的基本原理

  • 远近使用什么度量

    • 距离

    • 点A(1,2)，点B(4,6)，请问A和B之间的距离怎么计算

    • 欧式距离

    • distanceAB=(4−1)2+(6−2)2=32+42=5distance_{AB} = \sqrt{(4 - 1)^2 + (6-2)^2} = \sqrt{3^2 + 4^2} = 5

    • 点A(2,3,4)，点B(5,8,9):

    • distanceAB=(5−2)2+(8−3)2+(9−4)2distance_{AB} = \sqrt{(5-2)^2 + (8-3)^2 + (9-4)^2}

    • 点A(x1,x2,x3,x4,……xn)，B(y1,y2,y3,y4,……yn)：

    • distanceAB=∑i=1n(xi−yi)2distance_{AB} = \sqrt{\sum_{i=1}^n(x_i - y_i)^2}

    • 上面这个公式就是欧几里得距离公式

  • KNN算法的理论基础就是：

    • 欧式距离
    • 根据距离远近，选择邻居
    • 物以类聚人以群分
    • 这个算法不难！

  • KNN算法缺陷

    • k给多少比较好呢？
    • 请问绿色的点划归到红色类别，还是蓝色的类别？
    • 如果k = 3，找三个邻居，2个是红色，1个蓝色 投票，红色票数多，所以此时，绿色球划归到，红色的类别
    • 如果k = 5，找五个邻居，3个是蓝色，2个红色 投票，蓝色票数多，所以此时，绿色球划归到，蓝色的类别
    • 分歧，不一致，不稳定，给定的k值不同，结果可能会不同！

  • KNN算法怎么找到邻居的呢？

    • 电脑而言，给了一堆数据
    • 电脑，计算所有点的距离！
    • 然后排序！
    • 选择距离比较小的k个点！
    • 穷举
    • KNN算法，比较耗费时间，要求数据量不能太大，时间复杂度空间复杂度，比较大。

  • KNN这个算法，比较简单，但是，很多情况下，比较实用的。

    • 数据，都是存在规律，精确度要求不高，KNN这个算法，可以实现分类功能。

KNN的案例

  • 鸢尾花分类
  • 生长的环境不同，所以类别3类
  • 类别不同，性质不同：花萼长宽不一样，花瓣长宽不同了。
  • 植物学家，根据形状不同，进行分类
  • 分类算法使用流程：
    • 加载数据
    • 数据预处理，拆分
    • 声明算法，给定超参数
    • 训练算法，算法学习数据，归纳规律
    • 算法，通过数学，找到，数据和目标值之间的规律
    • 算法找到规律，应用
    • 实际使用了。

KNN超参数

  • 邻居
  • weights权重，话语权：uniform、distance
  • p = 1、2
  • metrics = minkowski
  • p = 1 曼哈顿距离
    • 这个距离表示远近方法
    • 红色的线就是曼哈顿距离
    • 蓝色和黄色等价曼哈顿距离
    • 绿色线就是欧式距离
  • p = 2 欧式距离

作业：

  • 使用KNN诊断是否患癌症
  • 早发现，提高治愈率
  • 体检，2000块钱，查一下癌症！
]]> <h3 id="KNN">KNN</h3> <ul> <li> <p>k nearest neighbors</p> </li> <li> <p>k近邻算法</p> </li> <li> <p>k表示个数</p> <ul> <li>你有几个好朋友？</li> <li>你有几个邻居 2-KNN http://git.molittle.site/posts/ccca0725.html 2025-06-10T05:49:32.000Z 2025-07-25T14:43:02.158Z 癌症诊断
  • 有一些微观数据，都是人体细胞内的数据
  • 中医：望闻问切
  • 西医：各种设备，检查一通
  • 无论中医还是西医：
    • 获取指标
    • 获取数据
    • 获取特征
  • 看病，通过，指标诊断
  • 设备越来越先进，获取更多微观数据、指标
  • 有一些病，先微观，变成宏观（感觉不舒服）
  • 量变到质变
  • 可以尝试找到围观数据和疾病之间的关系！
  • 使用算法寻找数据内部的规律
  • KNN调整超参数，准确率提升
  • 数据归一化、标准化，提升更加明显！

薪资预测

  • 属性清理，将没有属性删除
  • 一些属性是str类型的
  • pandas中map、agg、apply、transform这些都可以转变！
  • 建模
    • knn
    • knn.fit()
    • knn.predict()预测
    • knn.score()准确率，分类
  • 模型优秀，模型准确率更高
    • 超参数调整
    • 归一化、标准化
    • pandas.cut()，分箱操作，面元化操作，其实就是分类
    • 把相近的数值，归到一类中
    • 大学时候，体育成绩：优（90～100）、良（80～90）、中等（70～80）、及格（60～70）、不及格（<60）
    • 大学成绩，就是分箱操作。
    • 简明扼要。
]]> <h3 id="癌症诊断">癌症诊断</h3> <ul> <li>有一些微观数据，都是人体细胞内的数据</li> <li>中医：望闻问切</li> <li>西医：各种设备，检查一通</li> <li>无论中医还是西医： <ul> <li>获取指标</li> <li>获取数据</l 决策回归树与集成算法 http://git.molittle.site/posts/cbfbaea9.html 2025-06-10T05:49:32.000Z 2025-07-25T14:42:10.778Z 1、决策回归树原理概述

  • 与分类树一样

  • 裂分指标，使用的是MSE、MAE

    MSE(y,y^)=1nsamples∑i=0nsamples−1(yi−y^i)2\text{MSE}(y, \hat{y}) = \frac{1}{n_\text{samples}} \sum\limits_{i=0}^{n_\text{samples} - 1} (y_i - \hat{y}_i)^2

    MAE(y,y^)=1nsamples∑i=0nsamples−1∣yi−y^i∣\text{MAE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum\limits_{i=0}^{n_{\text{samples}}-1} \left| y_i - \hat{y}_i \right|

  • 决策回归树，认为它是分类问题，只是，分的类别多一些！！！

  • 只要树，分类回归，其实就是分类多和少的问题

2、决策回归树算例

2.1、决策树预测圆的轨迹

导包并创建数据与可视化

1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as np
from sklearn.tree import DecisionTreeRegressor
from sklearn import tree
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
import graphviz
X = np.linspace(0,2*np.pi,40).reshape(-1,1)
X_test = np.linspace(0,2*np.pi,187).reshape(-1,1)
# y 一个正弦波，余弦波，圆
y = np.c_[np.sin(X),np.cos(X)]
plt.figure(figsize=(3,3))
plt.scatter(y[:,0],y[:,1])

使用线性回归预测，看效果

1
2
3
4
5
6
linear = LinearRegression()
linear.fit(X,y) #将数据交给算法，学习，希望算法，找到规律
# X ----> y 是一个圆；预测X_test返回值y_ 如果预测好，也是圆
y_ = linear.predict(X_test)
plt.figure(figsize=(3,3))
plt.scatter(y_[:,0],y_[:,1])

使用决策树回归，看效果

1
2
3
4
5
6
7
8
model = DecisionTreeRegressor(criterion='mse',max_depth=3)
model.fit(X,y)#X 是40个点 y是一个圆
y_ = model.predict(X_test) #X_test是187点，预测y_应该是一个圆
# 请问y_中有多少数据？？？
print(y_.shape)
plt.figure(figsize=(6,6))
plt.scatter(y_[:,0],y_[:,1],color = 'green')
plt.savefig('./3-决策树回归效果.png',dpi = 200)

思考一下为什么画出来的图形是八个点？

决策回归树可视化

1
2
3
4
# 决策树形状
dot_data = tree.export_graphviz(model,filled=True)
graph = graphviz.Source(dot_data)
graph.render('./1-决策回归树')

因为决策树深度是3，所以最终得到8个叶节点，所以分成8类！

2.2、增加决策树深度

1
2
3
4
5
6
7
8
9
10
11
12
model = DecisionTreeRegressor(criterion='mse',max_depth=4)
model.fit(X,y)#X 是40个点 y是一个圆
y_ = model.predict(X_test) #X_test是187点，预测y_应该是一个圆
# 请问y_中有多少数据？？？
print(y_.shape)
plt.figure(figsize=(6,6))
plt.scatter(y_[:,0],y_[:,1],color = 'green')
plt.savefig('./4-增加深度决策树回归效果.png',dpi = 200)
# 决策树形状
dot_data = tree.export_graphviz(model,filled=True)
graph = graphviz.Source(dot_data)
graph.render('./5-增加深度决策回归树')

2.3、决策回归树分裂原理剖析

以上面深度为3的决策树为例

1、计算未分裂时，整体MSE:

MSE(y,y^)=1nsamples∑i=0nsamples−1(yi−y^i)2\text{MSE}(y, \hat{y}) = \frac{1}{n_\text{samples}} \sum\limits_{i=0}^{n_\text{samples} - 1} (y_i - \hat{y}_i)^2

1
2
mse = ((y - y.mean(axis = 0))**2).mean()
print('未分裂时，整体MSE:',mse)

2、根据分裂标准X[0] <= 3.142，计算分裂后的MSE：

1
2
3
4
5
6
cond = X <= 3.142
part1 = y[cond.reshape(-1)]
part2 = y[(~cond).reshape(-1)]
mse1 = ((part1 - part1.mean(axis = 0))**2).mean()
mse2 = ((part2 - part2.mean(axis = 0))**2).mean()
print(mse1,mse2)

3、寻找最佳分裂条件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
split_result = {}
mse_lower = 0.5
for i in range(len(X) - 1):
    split = round(X[i:i + 2].mean(),3)
    cond = X <= split
    part1 = y[cond.reshape(-1)]
    part2 = y[(~cond).reshape(-1)]
    mse1 = ((part1 - part1.mean(axis = 0))**2).mean()
    mse2 = ((part2 - part2.mean(axis = 0))**2).mean()
    mse = mse1 * len(part1)/cond.size + mse2 * len(part2)/cond.size
    mse_result.append(mse)
    if mse < mse_lower:
        split_result.clear()
        split_result[split] = [i,mse]
        mse_lower = mse
print('最佳分裂条件：',split_result)

根据打印输出，我们知道最佳裂分，索引是：19。分裂条件是：3.142。

结论：和直接使用决策回归树绘图显示的结果一模一样~

3、决策回归树 VS 线性回归

1、加载数据

1
2
3
4
5
6
7
8
9
10
import numpy as np
from sklearn.tree import DecisionTreeRegressor
from sklearn import tree
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
diabetes = datasets.load_diabetes()#糖尿病
X = diabetes['data']
y = diabetes['target']
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 911)

2、线性回归表现

1
2
3
linear = LinearRegression()
linear.fit(X_train,y_train)
linear.score(X_test,y_test)

3、决策树回归表现

1
2
3
4
5
6
7
8
9
10
11
12
13
import matplotlib.pyplot as plt
plt.rcParams['font.family'] = 'STKaiti'
max_depth = np.arange(1,16)
score = []
for d in max_depth:
    model = DecisionTreeRegressor(max_depth = d)
    model.fit(X_train,y_train)
    score.append(model.score(X_test,y_test))
plt.plot(max_depth,score,'ro-')
plt.xlabel('max_depth',fontsize = 18)
plt.ylabel('Score',fontsize = 18)
plt.title('决策树准确率随着深度变化',pad = 20,fontsize = 20)
plt.savefig('./6-决策树回归糖尿病.png',dpi = 200)

4、结论：

  • 对于这个案例，线性回归效果更好一些
  • 糖尿病这个数据，更适合使用方程对规律进行拟合
  • 在很多方面，决策树回归表现也优秀~

4、集成算法

4.1、集成算法概述

集成算法核心：

少数服从多数，人多力量大，三个臭皮匠顶个诸葛亮。

假设你有 100 个朋友给你出主意投资股票，你怎么做最终的决定？

  1. 选择最牛 x 的一个朋友的意见当作自己的意见（找到最好的单颗决策树）

  2. 所有朋友的意见投票，少数服从多数（随机森林）

  3. 还是牛一点的朋友多给几票，弱鸡一点的少给几票（Adaboost）

聚合模型：

所有朋友的意见投票, 少数服从多数（随机森林对应原理公式）

  • $G(x) = \frac{1}{n}\sum\limits_{i =1}^n1 \times g_i(x) $

牛一点的朋友多给几票，弱鸡一点的少给几票（Adaboost对应原理公式）

  • G(x)=1n∑i=1nαi×gi(x);αi≥0G(x) = \frac{1}{n}\sum\limits_{i =1}^n \alpha_i \times g_i(x) ;\alpha_i \ge 0​​​

4.2、构造不同模型（朋友）

同样的数据，行列都相同，不同的超参数，可以得到不同的模型。

同样的超参数，行相同，列不同，可以得到不同的模型。

同样的超参数，行不同，列相同，可以得到不同的模型。

同样的超参数，同样的数据，但是数据权重不同，可以得到不同的模型。

4.3、集成算法不同方式

  • 方式一Bagging（套袋法）

    • 对训练集进行抽样， 将抽样的结果用于训练 g(x)。
    • 并行，独立训练。
    • 随机森林random forest便是这一类别的代表。

  • 方式二Boosting（提升法）

    • 利用训练集训练出模型，根据本次模型的预测结果，调整训练集。
    • 然后利用调整后的训练集训练下一个模型。
    • 串行，需要第一个模型。
    • Adaboost，GBDT，Xgboost都是提升树算法典型代表。

4.4、Bagging集成算法步骤

  1. Bootstrap（独立自主） : 有放回地对原始数据集进行均匀抽样

  2. 利用每次抽样生成的数据集训练模型

  3. 最终的模型为每次生成的模型进行投票

  4. 其实 boosting 和 bagging 都不仅局限于对决策树这种基模型适应

  5. 如果不是同一种 base model，也可以做集成算法

5、随机森林

5.1、随机森林介绍

Bagging 思想 + 决策树就诞生了随机森林。

随机森林，都有哪些随机？

  • bagging生成一颗决策树时，随机抽样
  • 抽样后，分裂时，每一个结点都随机选择特征，从部分特征中筛选最优分裂条件

5.2、随机森林实战

1、导包加载数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import numpy as np
from sklearn import tree
from sklearn import datasets
from sklearn.model_selection import train_test_split
import graphviz
# ensemble 集成
# 随机森林
from sklearn.ensemble import RandomForestClassifier
# 作为对照
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
# 加载数据
X,y = datasets.load_iris(return_X_y=True)
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 112)

2、普通决策树

1
2
3
4
5
6
7
score = 0
for i in range(100):
    X_train,X_test,y_train,y_test = train_test_split(X,y)
    model = DecisionTreeClassifier()
    model.fit(X_train,y_train)
    score += model.score(X_test,y_test)/100
print('随机森林平均准确率是：',score)

3、随机森林（运行时间稍长，10s）

1
2
3
4
5
6
7
score = 0
for i in range(100):
    X_train,X_test,y_train,y_test = train_test_split(X,y)
    model = RandomForestClassifier()
    model.fit(X_train,y_train)
    score += model.score(X_test,y_test)/100
print('随机森林平均准确率是：',score)

结论：

  • 和决策树对比发现，随机森林分数稍高，结果稳定
  • 即降低了结果方差，减少错误率

4、逻辑斯蒂回归

1
2
3
4
5
6
7
8
9
import warnings
warnings.filterwarnings('ignore')
score = 0
for i in range(100):
    X_train,X_test,y_train,y_test = train_test_split(X,y)
    lr = LogisticRegression()
    lr.fit(X_train,y_train)
    score += lr.score(X_test,y_test)/100
print('逻辑斯蒂回归平均准确率是：',score)

结论：

  • 逻辑斯蒂回归这个算法更加适合鸢尾花这个数据的分类
  • 随机森林也非常优秀

5.3、随机森林可视化

1、创建随机森林进行预测

1
2
3
4
5
6
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 9)
forest = RandomForestClassifier(n_estimators=100,criterion='gini')
forest.fit(X_train,y_train)
score1 = round(forest.score(X_test,y_test),4)
print('随机森林准确率：',score1)
print(forest.predict_proba(X_test))

2、对比决策树

1
2
3
4
5
6
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 112)
model = DecisionTreeClassifier()
model.fit(X_train,y_train)
print('决策树准确率：',model.score(X_test,y_test))
proba_ = model.predict_proba(X_test)
print(proba_)

总结：

  • 一般情况下，随机森林比决策树更加优秀
  • 随机森林，是多棵树投票的概率，所以predict_proba()概率值，出现0.97
  • 单一决策树，不是，通过投票，而是通过决策树叶节点分类，所以概率要么是0，要么是1

3、绘制决策树

1
2
3
4
# 第一颗树类别
dot_data = tree.export_graphviz(forest[0],filled=True)
graph = graphviz.Source(dot_data)
graph
1
2
3
4
# 第五十颗树类别
dot_data = tree.export_graphviz(forest[49],filled=True)
graph = graphviz.Source(dot_data)
graph
1
2
3
4
# 第100颗树类别
dot_data = tree.export_graphviz(forest[-1],filled=True)
graph = graphviz.Source(dot_data)
graph

5.4、随机森林总结

随机森林主要步骤：

  • 随机选择样本（放回抽样）；

  • 随机选择特征；

  • 构建决策树；

  • 随机森林投票（平均）

优点:

  • 表现良好

  • 可以处理高维度数据(维度随机选择)

  • 辅助进行特征选择

  • 得益于 Bagging 可以进行并行训练

缺点：

  • 对于噪声过大的数据容易过拟合

6、极限森林

6.1、极限森林介绍

极限森林，都有哪些随机？

  • 极限森林中每一个决策树都采用原始训练集
  • 抽样后，分裂时，每一个结点分裂时，都进行特征随机抽样（一部分特征作为分裂属性）
  • 从分裂随机中筛选最优分裂条件

6.2、极限森林实战

1、加载数据

1
2
3
4
5
6
7
8
9
10
11
12
13
import warnings
warnings.filterwarnings('ignore')
import numpy as np
from sklearn.ensemble import RandomForestClassifier,ExtraTreesClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn import datasets
from sklearn.model_selection import train_test_split
import graphviz
from sklearn import tree

# 加载数据
X,y = datasets.load_wine(True)
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 119)

2、单棵决策树

1
2
3
4
5
clf = DecisionTreeClassifier()
clf.fit(X_train,y_train)
print('单棵决策树得分：',clf.score(X_test,y_test))
print('数据特征：',clf.n_features_)
print('节点分裂选择最大特征数量：',clf.max_features_)

3、随机森林

1
2
3
4
5
6
clf2 = RandomForestClassifier()
clf2.fit(X_train,y_train)
print('随机森林得分：',clf2.score(X_test,y_test))
print('数据特征：',clf2.n_features_)
for t in clf2:
    print('节点分裂选择最大特征数量：',t.max_features_)

4、极限森林

1
2
3
4
5
6
clf3 = ExtraTreesClassifier(max_depth = 3)
clf3.fit(X_train,y_train)
print('极限森林得分：',clf3.score(X_test,y_test))
print('数据特征：',clf3.n_features_)
for t in clf3:
    print('节点分裂选择最大特征数量：',t.max_features_)

5、可视化

1
2
3
dot_data = tree.export_graphviz(clf3[0],filled=True)
graph = graphviz.Source(dot_data)
graph

1
2
3
dot_data = tree.export_graphviz(clf3[49],filled=True)
graph = graphviz.Source(dot_data)
graph

6、分裂标准代码演练

6.1、计算未分裂gini系数

1
2
3
4
5
6
7
count = []
for i in range(3):
    count.append((y_train == i).sum())
count = np.array(count)
p = count / count.sum()
gini = (p * (1 - p)).sum()
print('未分裂，gini系数是：',round(gini,3))

6.2、根据属性寻找最佳分裂条件

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
f = np.sort(X_train[:,11])
gini_lower = 1
best_split = {}
for i in range(len(f) - 1):
    split = round(f[i:i + 2].mean(),3)
    cond = X_train[:,11] <= split
    part1 = y_train[cond]
    part2 = y_train[~cond]
    # 计算每一部分的gini系数
    count1 = []
    count2 = []
    for j in range(3):
        count1.append((part1 == j).sum())
        count2.append((part2 == j).sum())
    count1,count2 = np.array(count1),np.array(count2)
    p1 = count1 / count1.sum()
    p2 = count2 / count2.sum()
    gini1 = round((p1 * (1 - p1)).sum(),3)
    gini2 = round((p2 * (1 - p2)).sum(),3)
    # 计算整体的gini系数
    gini = round(gini1 * count1.sum()/(y_train.size) + gini2 * count2.sum()/(y_train.size),3)
    if gini < gini_lower:
        gini_lower = gini
        best_split.clear()
        best_split[j] = split
    print(split,gini1,gini2,gini,count1,count2)
print(best_split,gini_lower)

结论：

  • 通过打印输出可知，极限森林分裂条件，并不是最优的
  • 并没有使用gini系数最小的分裂点
  • 分裂值，具有随机性，这正是极限森林的随机所在！
]]> <h3 id="1、决策回归树原理概述">1、决策回归树原理概述</h3> <ul> <li> <p>与分类树一样</p> </li> <li> <p>裂分指标，使用的是MSE、MAE</p> <p><span class="katex"><span class="katex-m 决策树算法 http://git.molittle.site/posts/ef296a07.html 2025-06-10T05:49:32.000Z 2025-07-25T14:42:17.360Z 1、决策树概述

决策树是属于有监督机器学习的一种，起源非常早，符合直觉并且非常直观，模仿人类做决策的过程，早期人工智能模型中有很多应用，现在更多的是使用基于决策树的一些集成学习的算法。这一章我们把决策树算法理解透彻了，非常有利于后面去学习集成学习。

1.1、示例一

我们有如下数据：

ID拥有房产（是/否）婚姻[单身，已婚，离婚]年收入（单位：千元）无法偿还债务（是/否）
1是单身125否
2否已婚100否
3否单身70否
4是已婚120否
5否离婚95是
6否已婚60否
7是离婚220否
8否单身85是
9否已婚75否
10否单身90是

上表根据历史数据，记录已有的用户是否可以偿还债务，以及相关的信息。通过该数据，构建的决策树如下：

比如新来一个用户：无房产，单身，年收入55K，那么根据上面的决策树，可以预测他无法偿还债务（蓝色虚线路径）。从上面的决策树，还可以知道是否拥有房产可以很大的决定用户是否可以偿还债务，对借贷业务具有指导意义。

1.2、示例二

女孩母亲要给她介绍对象，年龄是多少，母亲说24。长得帅吗？挺帅的。收入高吗？中等收入。是公务员吗？母亲说，是的。女孩：好，我去见见。

根据实力构建决策树：

问题：图片是二叉树吗？

决策树是标准的二叉树，每个节点只有两个分支~

  • 上面那棵树中，属性：绿色的节点（年龄、长相、收入、是否是公务员）
    • 属性叫做，data，数据，一般使用X表示
    • 跟属性对应，目标值（橘色节点），一般使用y表示
  • 构建这棵树时，先后顺序，每个人，标准不同，树结构不同
  • 计算机，构建树，标准一致的，构建出来的树，一致

1.3、决策树算法特点

  • 可以处理非线性的问题

  • 可解释性强，没有方程系数 θ\theta

  • 模型简单，模型预测效率高 if else

2、DecisionTreeClassifier使用

2.1、算例介绍

其中s、m和l分别表示小、中和大。

账号是否真实跟属性：日志密度、好友密度、是否使用真实头像有关系~

2.2、构建决策树并可视化

数据创建

1
2
3
4
5
6
7
8
9
import numpy as np
import pandas as pd
y = np.array(list('NYYYYYNYYN'))
print(y)
X = pd.DataFrame({'日志密度':list('sslmlmmlms'),
                  '好友密度':list('slmmmlsmss'),
                  '真实头像':list('NYYYYNYYYY'),
                  '真实用户':y})
X

模型训练（报错，原因：数据类型是字符串）

1
2
3
4
5
from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()

model.fit(X,y)

数据修改（map函数，进行数据转换）

1
2
3
4
X['日志密度'] = X['日志密度'].map({'s':0,'m':1,'l':2})
X['好友密度'] = X['好友密度'].map({'s':0,'m':1,'l':2})
X['真实头像'] = X['真实头像'].map({'N':0,'Y':1})
X

模型训练可视化

1
2
3
4
5
6
7
8
9
import matplotlib.pyplot as plt
# 使用信息熵，作为分裂标准
model = DecisionTreeClassifier(criterion='entropy')
model.fit(X,y)
plt.rcParams['font.family'] = 'STKaiti'
plt.figure(figsize=(12,16))
fn = X.columns
_ = tree.plot_tree(model,filled = True,feature_names=fn)
plt.savefig('./iris.jpg')

数据可视化另一种方式，安装教程

1
2
3
4
5
6
7
8
9
10
11
12
13
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
import graphviz
from sklearn import tree
model = DecisionTreeClassifier(criterion='entropy')
model.fit(X,y)
dot_data = tree.export_graphviz(model, out_file=None, 
                            feature_names= X.columns,# 特征名
                            class_names=np.unique(y),# 类别名
                            filled=True, # 填充颜色
                            rounded=True) # 圆角
graph = graphviz.Source(dot_data)
graph.render('Account',format='png')

修改中文乱码

1
2
3
4
5
6
7
8
9
import re
# 打开 dot_data.dot，修改 fontname="支持的中文字体"
f = open('Account', 'r', encoding='utf-8')
with open('./Account2', 'w', encoding="utf-8") as file:
    file.write(re.sub(r'fontname=helvetica', 'fontname=Fangsong', f.read()))
f.close()
# 从文件中加载，展示
graph = graphviz.Source.from_file('./Account2')
graph.render('Account')

2.3、信息熵

  • 构建好一颗树，数据变的有顺序了（构建前，一堆数据，杂乱无章；构建一颗，整整齐齐，顺序），用什么度量衡表示，数据是否有顺序：信息熵

  • 物理学，热力学第二定律（熵），描述的是封闭系统的混乱程度

  • 信息熵，和物理学中熵类似的

  • H(x)=−∑i=1np(x)log2p(x)H(x) = -\sum\limits_{i = 1}^n p(x)log_2p(x)

  • H(x)=∑i=1np(x)log21p(x)H(x) = \sum\limits_{i = 1}^n p(x)log_2\frac{1}{p(x)}​

2.4、信息增益

信息增益是知道了某个条件后，事件的不确定性下降的程度。写作 g(X,Y)。它的计算方式为熵减去条件熵，如下

g(X,y)=H(Y)−H(Y∣X)g(X,y) \rm = H(Y) - H(Y|X)​

表示的是，知道了某个条件后，原来事件不确定性降低的幅度。

2.5、手动计算实现决策树分类

数据整合

1
2
X['真实用户'] = y
X

计算未划分信息熵

1
2
3
s = X['真实用户']
p = s.value_counts()/s.size
(p * np.log2(1/p)).sum()

按照日志密度进行划分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
x = X['日志密度'].unique()
x.sort()
# 如何划分呢，分成两部分
for i in range(len(x) - 1):
    split = x[i:i+2].mean()
    cond = X['日志密度'] <= split
    # 概率分布
    p = cond.value_counts()/cond.size
    # 按照条件划分，两边的概率分布情况
    indexs =p.index
    entropy = 0
    for index in indexs:
        user = X[cond == index]['真实用户']
        p_user = user.value_counts()/user.size
        entropy += (p_user * np.log2(1/p_user)).sum() * p[index]
    print(split,entropy)

筛选最佳划分条件

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
columns = ['日志密度','好友密度','真实头像']
lower_entropy = 1
condition = {}
for col in columns:
    x = X[col].unique()
    x.sort()
    print(x)
    # 如何划分呢，分成两部分
    for i in range(len(x) - 1):
        split = x[i:i+2].mean()
        cond = X[col] <= split
        # 概率分布
        p = cond.value_counts()/cond.size
        # 按照条件划分，两边的概率分布情况
        indexs =p.index
        entropy = 0
        for index in indexs:
            user = X[cond == index]['真实用户']
            p_user = user.value_counts()/user.size
            entropy += (p_user * np.log2(1/p_user)).sum() * p[index]
        print(col,split,entropy)
        if entropy < lower_entropy:
            condition.clear()
            lower_entropy = entropy
            condition[col] = split
print('最佳列分条件是：',condition)

进一步列分

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
cond = X['好友密度'] < 0.5
X_ = X[cond]
columns = ['日志密度','真实头像']
lower_entropy = 1
condition = {}
for col in columns:
    x = X_[col].unique()
    x.sort()
    print(x)
    # 如何划分呢，分成两部分
    for i in range(len(x) - 1):
        split = x[i:i+2].mean()
        cond = X_[col] <= split
        # 概率分布
        p = cond.value_counts()/cond.size
        # 按照条件划分，两边的概率分布情况
        indexs =p.index
        entropy = 0
        for index in indexs:
            user = X_[cond == index]['真实用户']
            p_user = user.value_counts()/user.size
            entropy += (p_user * np.log2(1/p_user)).sum() * p[index]
        print(col,split,entropy)
        if entropy < lower_entropy:
            condition.clear()
            lower_entropy = entropy
            condition[col] = split
print('最佳列分条件是：',condition)

3、决策树分裂指标

常用的分裂条件时：

  • 信息增益

  • Gini系数

  • 信息增益率

  • MSE（回归问题）

3.1、信息熵（ID3）

在信息论里熵叫作信息量，即熵是对不确定性的度量。从控制论的角度来看，应叫不确定性。信息论的创始人香农在其著作《通信的数学理论》中提出了建立在概率统计模型上的信息度量。他把信息定义为“用来消除不确定性的东西”。在信息世界，熵越高，则能传输越多的信息，熵越低，则意味着传输的信息越少。还是举例说明，假设 Dammi 在买衣服的时候有颜色，尺寸，款式以及设计年份四种要求，而 Sara 只有颜色和尺寸的要求，那么在购买衣服这个层面上 Dammi 由于选择更多因而不确定性因素更大，最终 Dammi所获取的信息更多，也就是熵更大。所以信息量=熵=不确定性，通俗易懂。在叙述决策树时我们用熵表示不纯度（Impurity）。

对应公式如下：

H(x)=−∑i=1np(x)log2p(x)H(x) = -\sum\limits_{i = 1}^n p(x)log_2p(x)​

熵的变化越大，说明划分越纯，信息增益越大~

3.2、Gini系数（CART）

基尼系数是指国际上通用的、用以衡量一个国家或地区居民收入差距的常用指标。

基尼系数最大为“1”，最小等于“0”。基尼系数越接近 0 表明收入分配越是趋向平等。国际惯例把 0.2 以下视为收入绝对平均，0.2-0.3 视为收入比较平均；0.3-0.4 视为收入相对合理；0.4-0.5 视为收入差距较大，当基尼系数达到 0.5 以上时，则表示收入悬殊。

基尼系数的实际数值只能介于 0～1 之间，基尼系数越小收入分配越平均，基尼系数越大收入分配越不平均。国际上通常把 0.4 作为贫富差距的警戒线，大于这一数值容易出现社会动荡。

Gini 系数越小，代表集合中的数据越纯，所有我们可以计算分裂前的值在按照某个维度对数据集进行划分，然后可以去计算多个节点的 Gini 系数。

对应公式如下：

gini=∑i=1npi(1−pi)\rm gini = \sum\limits_{i = 1}^np_i(1 - p_i)​

在对数据进行分类是gini系数的变化越大，说明划分越纯，效果越好~

3.3、信息增益率

大学期末的数学考试只有单选题。对于一个完全没有学习过的学生。该如何过关呢？

4个选项是正确选项的概率都是1/4。那么单项选择题的答案的熵就是：

H(Y)=−0.25log2(0.25)×4=2bitH(Y) \rm = -0.25log_2(0.25) \times 4 = 2bit​

在学霸圈做单项选择题有一个秘籍：三长一短选最短，三短一长选最长。姑且假设学霸的秘籍一般都是正确的。

如果在某场考试中，有10%的单项选题是三长一短，10%的选题是三短一长。计算该考试单项选题的关于长短题的条件熵：

题目类型答案概率题目概率
三长一短(1,0,0,0)熵是0，结果确定！10%
三短一长(1,0,0,0)熵是010%
一样长(0.25,0.25,0.25,0.25)熵是280%

计算条件熵（条件就是：题目不同类型）

H(Y∣X)=0.1×0+0.1×0+0.8×2=1.6bitH(Y|X) \rm = 0.1\times 0 + 0.1 \times 0 + 0.8 \times 2 = 1.6bit​

那么信息增益是：

g(X,Y)=H(Y)−H(Y∣X)=2−1.6=0.4bitg(X,Y) \rm = H(Y) - H(Y|X) = 2 - 1.6 = 0.4bit​

信息增益率在信息增益的基础上增加了惩罚项，惩罚项是特征的固有值。

写作 gr(X,Y)。定义为信息增益除以特征的固有值，如下：

gr(X,Y)=g(X,Y)Info(X)gr(X,Y) = \frac{g(X,Y)}{Info(X)}​

Info(X)=−∑v∈values(X)num(v)num(X)log2num(v)num(X)Info(X) = -\sum\limits_{v \in values(X)}\frac{num(v)}{num(X)}log_2{\frac{num(v)}{num(X)}}

计算上面单选题题目长短案例的信息增益率：

Info(X)=−(0.1×log20.1×2+0.8×log20.8)=0.92Info(X) = -(0.1 \times log_20.1 \times 2 + 0.8 \times log_20.8) = 0.92

gr(X,Y)=g(X,Y)Info(X)=0.40.92=0.43gr(X,Y) = \frac{g(X,Y)}{Info(X)} = \frac{0.4}{0.92} = 0.43​​

对于取值多的属性，尤其一些连续型数值，这个单独的属性就可以划分所有的样本，使得所有分支下的样本集合都是“纯的”（最极端的情况是每个叶子节点只有一个样本）。
一个属性的信息增益越大，表明属性对样本的熵减少的能力更强，这个属性使得数据由不确定性变成确定性的能力越强。
所以如果是取值更多的属性，更容易使得数据更“纯”（尤其是连续型数值），其信息增益更大，决策树会首先挑选这个属性作为树的顶点。结果训练出来的形状是一棵庞大且深度很浅的树，这样的划分是极为不合理的。

C4.5使用了信息增益率，在信息增益的基础上除了一项split information,来惩罚值更多的属性。从而使划分更加合理！

3.4、MSE

用于回归树，后面章节具体介绍

4、鸢尾花分类代码实战

4.1、决策树分类鸢尾花数据集

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
from sklearn.tree import DecisionTreeClassifier
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn import tree
import matplotlib.pyplot as plt

X,y = datasets.load_iris(return_X_y=True)

# 随机拆分
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 256)

# max_depth调整树深度：剪枝操作
# max_depth默认，深度最大，延伸到将数据完全划分开为止。
model = DecisionTreeClassifier(max_depth=None,criterion='entropy')
model.fit(X_train,y_train)
y_ = model.predict(X_test)
print('真实类别是：',y_test)
print('算法预测是：',y_)
print('准确率是：',model.score(X_test,y_test))
# 决策树提供了predict_proba这个方法，发现这个方法，返回值要么是0，要么是1
model.predict_proba(X_test)

4.2、决策树可视化

1
2
3
4
5
6
7
8
9
import graphviz
from sklearn import tree
# 导出数据
dot_data = tree.export_graphviz(model,feature_names=fn,
                     class_names=iris['target_names'],# 类别名
                     filled=True, # 填充颜色
                     rounded=True,)
graph = graphviz.Source(dot_data)
graph.render('iris')

4.3、决策树剪枝

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
# 设置图片的尺寸
# 鸢尾花4个属性
iris = datasets.load_iris()

X = iris['data']
y = iris['target']
fn = iris['feature_names']
# 随机拆分
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 256)

# max_depth调整树深度：剪枝操作
# max_depth默认，深度最大，延伸到将数据完全划分开为止。
# min_impurity_decrease（节点划分最小不纯度）如果某节点的不纯度(基尼系数，信息增益，均方差)小于这个阈值，则该节点不再生成子节点
# max_depth（决策树最大深度）；min_samples_split（内部节点再划分所需最小样本数）
# min_samples_leaf（叶子节点最少样本数）；max_leaf_nodes（最大叶子节点数）
model = DecisionTreeClassifier(criterion='entropy',min_impurity_decrease=0.2)
model.fit(X_train,y_train)
y_ = model.predict(X_test)
print('真实类别是：',y_test)
print('算法预测是：',y_)
print('准确率是：',model.score(X_test,y_test))
# 导出数据
dot_data = tree.export_graphviz(model,feature_names=fn,
                     class_names=iris['target_names'],# 类别名
                     filled=True, # 填充颜色
                     rounded=True,)
graph = graphviz.Source(dot_data)
graph.render('./13-iris-裁剪')

4.4、选择合适的超参数并可视化

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
import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn import tree
import matplotlib.pyplot as plt

X,y = datasets.load_iris(return_X_y=True)

# 随机拆分
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 256)
depth = np.arange(1,16)
err = []
for d in depth:
    model = DecisionTreeClassifier(criterion='entropy',max_depth=d)
    model.fit(X_train,y_train)
    score = model.score(X_test,y_test)
    err.append(1 - score)
    print('错误率为%0.3f%%' % (100 * (1 - score)))
plt.rcParams['font.family'] = 'STKaiti'
plt.plot(depth,err,'ro-')
plt.xlabel('决策树深度',fontsize = 18)
plt.ylabel('错误率',fontsize = 18)
plt.title('筛选合适决策树深度')
plt.grid()
plt.savefig('./14-筛选超参数.png',dpi = 200)

4.5、决策树副产物

  • 特征重要性

    1
    model.feature_importances_

  • 你想一下逻辑斯蒂回归，是否也有这个属性呢？

]]> <h3 id="1、决策树概述">1、决策树概述</h3> <p>决策树是属于有监督机器学习的一种，起源非常早，符合直觉并且非常直观，模仿人类做决策的过程，早期人工智能模型中有很多应用，现在更多的是使用基于决策树的一些集成学习的算法。这一章我们把决策树算法理解透彻了，非常有利于后 条件随机场CRF http://git.molittle.site/posts/957271c3.html 2025-06-10T05:49:32.000Z 2025-06-10T12:38:41.708Z 1、条件随机场CRF概述

将之前所有的观测作为未来预测的依据是不现实的，因为其复杂度会随着观测数量的增加而无限制地增长。因此，就有了马尔科夫模型，即假定未来的预测仅与最近的观测有关，而独立于其他所有的观测。

通过引入隐变量，解决Markov Model需要强独立性的问题，即隐马尔可夫模型 HMM。

隐马尔可夫模型HMM为生成式模型，计算联合概率分布P(X,Z)P(X,Z)​ ；

条件随机场CRF则是判别式模型，计算条件概率 P(Y∣X)P(Y|X)。由于 CRF 利用最大熵模型的思路建立条件概率模型，对于观测序列并没有做马尔科夫假设，可以得到全局最优，而HMM则是在马尔科夫假设下建立的联合分布，会出现局部最优的情况。（此处 Y,ZY,Z 均代表隐变量，XX​ 为观测变量)

1.1、马尔可夫 Markov

引例：假设我们观测一个二值变量，这个二值变量表示某一天是否下雨。给定这个变量的一系列观测，我们希望预测下一天是否会下雨。

  • 如果我们将所有的数据都看成独立同分布的， 那么我们能够从数据中得到的唯一的信息就是雨天的相对频率；
  • 然而，我们知道天气经常会呈现出持续若干天的趋势。因此，观测到今天是否下雨对于预测明天是否下雨会有极大的帮助。

我们可以使用概率的乘积规则来表示观测序列的联合概率分布，形式为：

P(x1,x2,…,XN)=p(x1)∏n=2Np(xn∣x1,x2,…,xn−1)P(x_1,x_2,…,X_N) = p(x_1)\prod\limits_{n=2}^Np(x_n|x1,x2,…,x_{n-1})

利用马尔科夫性（一个马尔可夫过程可以表示为系统在状态转移过程中，第 n 次结果只受第 n-1 次结果的影响，即只与当前状态有关，而与过去状态，即与系统的初始状态和此次转移前的所有状态无关），可以将上式变为一阶马尔科夫链

P(x1,x2,…,XN)=p(x1)∑n=2Np(xn∣xn−1)P(x_1,x_2,…,X_N) = p(x_1)\sum\limits_{n=2}^Np(x_n|x_{n-1})​

1.2、隐马尔可夫 HMM

隐变量：离散

观测变量：离散或连续

引例：以句子和词性对应为例，观测变量 X={x1,x2,…,xn}X = \{x_1,x_2,…,x_n\}​ 为显式的句子，隐变量 Z={z1,z2,…,zn}Z = \{z_1,z_2,…,z_n\} 为每一个单词对应的词性。

观测变量和隐变量上的联合概率分布为：

P(X,Z∣λ)=P(z1∣π)[∏n=2NP(zn∣zn−1,A)]∏m=1NP(xm∣zm,B)P(X,Z|\lambda) = P(z_1|\pi)[\prod\limits_{n=2}^NP(z_n|z_{n-1},A)]\prod\limits_{m=1}^NP(x_m|z_m,B)​​

P(X,Z∣λ)=αt=∑j=1N[∑n=1Nαt−1×Ai]×Bj(t−1)P(X,Z|\lambda) =\alpha_t =\sum\limits_{j = 1}^N[\sum\limits_{n=1}^N\alpha_{t-1} \times A_i]\times B_j(t-1)​​​​​​​​​​

定义HMM模型总用到的变量

给定模型 λ=(A,B,Π)\lambda = (A,B,\Pi)​ 和观测序列 X={x1,x2,…,xn}X = \{x_1,x_2,…,x_n\}​ ，求观测序列 X 在模型 λ\lambda​下出现的条件概率 P(X∣λ)P(X|\lambda)​：

  • A = [aija_{ij}] 是隐藏状态转义概率矩阵
  • B = [bj(k)b_j(k)​] 就是观测状态生成概率矩阵，k表示时刻
  • Π=πi\Pi = \pi_i​ 是隐藏状态的初始概率分布

举例说明：

我们的观察集是：

V={红，白}，M=2\rm V = \{红，白\}，M = 2

我们的状态集合是：

Q={盒子一，盒子二，盒子三}，N=3\rm Q = \{盒子一，盒子二，盒子三\}，N= 3​

球的颜色观测序列

O={红，白，红}\rm O = \{红，白，红\}​

观察序列和状态序列的长度都是3。

初始状态分布为：

Π=[0.2,0.4,0.4]T\rm \Pi = [0.2,0.4,0.4]^T

状态转移概率分布矩阵为（三个盒子之间的状态转移、转变）：

A=[0.50.20.30.30.50.20.20.30.5]\rm A = \begin{bmatrix}0.5 & 0.2 & 0.3\\0.3 & 0.5 & 0.2\\0.2 & 0.3 & 0.5\end{bmatrix}​​​​

观测状态矩阵

B=[0.50.50.40.60.70.3]\rm B = \begin{bmatrix}0.5 & 0.5\\0.4 &0.6\\0.7&0.3\end{bmatrix}​​

HMM可以解决的三个问题：

  • 评估观察序列概率。

  • 模型参数学习。

  • 预测问题/解码问题。

1.3、马尔可夫随机场定义

什么叫随机场（MMF，Markov Random Field）？

随机场是由若干个位置组成的整体，当给每一个位置中按照某种分布随机赋予一个值之后，其全体就叫做随机场。

例：假如我们有一个十个词形成的句子需要做词性标注。这十个词每个词的词性可以在我们已知的词性集合（名词，动词…)中去选择。当我们为每个词选择完词性后，这就形成了一个随机场。

马尔可夫随机场是随机场的一个具有马尔可夫性得特例，它假设随机场中某一个位置的赋值仅仅与和它相邻的位置的赋值有关，和与其不相邻的位置的赋值无关。

例：如果我们假设所有词的词性只和它相邻的词的词性有关时，这个随机场就特化成一个马尔科夫随机场。比如第三个词的词性除了与自己本身的位置有关外，只与第二个词和第四个词的词性有关。

1.4、马尔可夫随机场拆解

马尔可夫随机场（Markov Random Field）包含两层意思。

马尔可夫性质：它指的是一个随机变量序列按时间先后关系依次排开的时候，第N+1时刻的分布特性，与N时刻以前的随机变量的取值无关。拿天气来打个比方。如果我们假定天气是马尔可夫的，其意思就是我们假设今天的天气仅仅与昨天的天气存在概率上的关联，而与前天及前天以前的天气没有关系。其它如传染病和谣言的传播规律，就是马尔可夫的。

随机场：当给每一个位置中按照某种分布随机赋予相空间的一个值之后，其全体就叫做随机场。我们不妨拿种地来打个比方。其中有两个概念：位置（site），相空间（phase space）。"位置"好比是一亩亩农田；“相空间"好比是种的各种庄稼。我们可以给不同的地种上不同的庄稼，这就好比给随机场的每个"位置”，赋予相空间里不同的值。所以，通俗的说，随机场就是在哪块地里种什么庄稼的事情。

马尔可夫随机场：马尔科夫随机场是具有马尔科夫特性的随机拿种地打比方，如果任何一块地里种的庄稼的种类仅仅与它邻近的地里种的庄稼的种类有关，与其它地方的庄稼的种类无关，那么这些地里种的庄稼的集合，就是一个马尔可夫随机场。

1.5、条件随机场 CRF

条件随机场 Conditional Random Field 是 马尔可夫随机场 + 隐状态的特例。

区别于生成式的隐马尔可夫模型HMM，CRF是判别式的。

假设我们有训练数据(X,Y)，X是属性集合，Y是类别标记。这时来了一个新的样本 xx，我们想要预测它的类别 yy。我们最终的目的是求得最大的条件概率 P(y∣x)P(y|x)​ 作为新样本的分类。

生成式模型：

一般会对每一个类建立一个模型，有多少个类别，就建立多少个模型。比如说类别标签有｛猫，狗，猪｝，那首先根据猫的特征学习出一个猫的模型，再根据狗的特征学习出狗的模型，之后分别计算新样本 xx​ 跟三个类别的联合概率 P(x,y)P(x,y)​ ，然后根据贝叶斯公式：

P(y∣x)=P(x,y)P(x)P(y|x) = \frac{P(x,y)}{P(x)}​​

分别计算P(y∣x)P(y|x)​​ ，选择三类中最大的 P(y∣x)P(y|x)​​ 作为样本的分类。

判别式模型：

根据训练数据得到分类函数和分界面，比如说根据 SVM 模型得到一个分界面，然后直接计算条件概率 P(y∣x)P(y|x)，我们将最大的 P(y∣x)P(y|x)​ 作为新样本的分类。判别式模型是对条件概率建模，学习不同类别之间的最优边界，无法反映训练数据本身的特性，能力有限，其只能告诉我们分类的类别。

两模型区别：

不管是生成式模型还是判别式模型，它们最终的判断依据都是条件概率 P(y∣x)P(y|x) ，但是生成式模型先计算了联合概率 P(y∣x)P(y|x) ，再由贝叶斯公式计算得到条件概率。因此，生成式模型可以体现更多数据本身的分布信息，其普适性更广。

CRF 试图对多个随机变量（代表状态序列）在给定观测序列的值之后的条件概率进行建模：

给定观测序列 ，X={x1,x2,…,xn}X = \{x_1,x_2,…,x_n\} 以及隐状态序列 Y={y1,y2,…,yn}Y = \{y_1,y_2,…,y_n\}的情况下，构建条件概率模型 P(Y∣X)P(Y|X)。若随机变量 Y 构成的是一个马尔科夫随机场，则 P(Y∣X)P(Y|X) 为条件随机场 CRF。

与HMM类似，CRF也关心如下三种问题：

  • 评估观察序列概率。

  • 模型参数学习。

  • 预测问题/解码问题。

2、实体命名案例

2.1、三方库安装与导包

1
2
3
4
5
6
# pip install nltk
import nltk # Natural Language Toolkit 自然语言处理工具包

# pip install nltk
import sklearn_crfsuite # 条件随机场Python库
from sklearn_crfsuite import metrics

2.2、数据加载与配置

1
2
3
4
5
6
7
# 网络设置，跳过安全验证
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
# 下载比较慢，不稳定
# 可以从百度网盘上下载，解压（解压到当前目录C:\Users\likai）到：C:\Users\likai\nltk_data
nltk.download('conll2002') # 下载数据，下载路径：C:\Users\likai\AppData\Roaming\nltk_data
nltk.corpus.conll2002.fileids() # 查看数据类别

加载训练和测试数据

1
2
3
4
5
%%time
train_sents = list(nltk.corpus.conll2002.iob_sents('esp.train'))
test_sents = list(nltk.corpus.conll2002.iob_sents('esp.testb'))
print('训练数据长度：',len(train_sents))
print('测试数据长度：',len(test_sents))

2.3、语料库介绍

  • 通用语料库：CoNLL2002

  • 语言：西班牙语

  • 训练集：8323句

  • 测试集：1517句

  • 概念：一般来说，标注列表为[‘O’ ,‘B-MISC’, ‘I-MISC’, ‘B-ORG’ ,‘I-ORG’, ‘B-PER’ ,‘I-PER’, ‘B-LOC’ ,‘I-LOC’]。其中，一般一共分为四大类：PER（人名），LOC（位置），ORG（组织）以及MISC（大杂烩），而且 B 表示开始，I 表示中间，O 表示单字词。

  • 语料格式：三列，分别表示词汇、词性、实体类型；使用Bakeoff-3评测中所采用的的BIO标注集即：
    - B-PER、I-PER 代表人名首字、人名非首字
    - B-LOC、I-LOC 代表地名首字、地名非首字
    - B-ORG、I-ORG 代表组织机构名首字、组织机构名非首字
    - O 代表该字不属于命名实体的一部分。
    - 如：(‘Australia’, ‘NP’, ‘B-LOC’)

  • 和其他语言一样，西班牙语也有很多词性，如：冠词、代词、动词、名词等等

    • 例如：NP表示专有名词，PP表示过去分词
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
display(train_sents[0],test_sents[-100])
'''
[('Melbourne', 'NP', 'B-LOC'),
 ('(', 'Fpa', 'O'),
 ('Australia', 'NP', 'B-LOC'),
 (')', 'Fpt', 'O'),
 (',', 'Fc', 'O'),
 ('25', 'Z', 'O'),
 ('may', 'NC', 'O'),
 ('(', 'Fpa', 'O'),
 ('EFE', 'NC', 'B-ORG'),
 (')', 'Fpt', 'O'),
 ('.', 'Fp', 'O')]
[('Valladolid', 'NC', 'B-LOC'),
 (',', 'Fc', 'O'),
 ('23', 'Z', 'O'),
 ('may', 'NC', 'O'),
 ('(', 'Fpa', 'O'),
 ('EFE', 'NC', 'B-ORG'),
 (')', 'Fpt', 'O'),
 ('.', 'Fp', 'O')]
'''

2.4、特征处理

主要选择处理了如下几个特征：

  • 当前词的小写格式
  • 当前词的后缀
  • 当前词是否全大写 isupper
  • 当前词的首字母大写，其他字母小写判断 istitle
  • 当前词是否为数字 isdigit
  • 当前词的词性
  • 当前词的词性前缀
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
def word2features(sent, i):
    word = sent[i][0]
    postag = sent[i][1]
    # 当前词的特征信息
    features = {
        'word.lower()': word.lower(), # 小写形式
        'word[-3:]': word[-3:], # 词切片
        'word[-2:]': word[-2:],
        'word.isupper()': word.isupper(),# 判断是否大写
        'word.istitle()': word.istitle(), # 当前词的首字母大写，其他字母小写判断
        'word.isdigit()': word.isdigit(), # 判断是否是数字
        'postag': postag, # 词性
        'postag[:2]': postag[:2]} # 词性切片，去一部分
    
    # 前一个词的特征信息
    if i > 0:
        word1 = sent[i-1][0]
        postag1 = sent[i-1][1]
        features.update({
            '-1:word.lower()': word1.lower(),
            '-1:word.istitle()': word1.istitle(),
            '-1:word.isupper()': word1.isupper(),
            '-1:postag': postag1,
            '-1:postag[:2]': postag1[:2]})
    else:
        features['BOS'] = True # 表示开始
        
    # 后一个词的特征信息
    if i < len(sent)-1:
        word1 = sent[i+1][0]
        postag1 = sent[i+1][1]
        features.update({
            '+1:word.lower()': word1.lower(),
            '+1:word.istitle()': word1.istitle(),
            '+1:word.isupper()': word1.isupper(),
            '+1:postag': postag1,
            '+1:postag[:2]': postag1[:2]})
    else:
        features['EOS'] = True # 表示结束
    return features # 返回词特征信息

# 文本数据特征提取
def sent2features(sent):
    return [word2features(sent, i) for i in range(len(sent))]

# 文本数据对应词性
def sent2labels(sent):
    return [label for token, postag, label in sent]

2.4、文本数据特征提取

1
2
3
4
5
6
7
8
9
%%time
X_train = [sent2features(s) for s in train_sents]
y_train = [sent2labels(s) for s in train_sents]

X_test = [sent2features(s) for s in test_sents]
y_test = [sent2labels(s) for s in test_sents]

display(y_train[0],X_train[0])
display(y_test[0],X_test[0])

2.5、条件随机场CRF建模

1
2
3
4
5
6
7
8
9
10
%%time
crf = sklearn_crfsuite.CRF(
    c1=0.1,# L1正则化系数
    c2=0.1, # L2正则化系数
    max_iterations=100, # 梯度下降迭代次数
    all_possible_transitions=True)
# all_possible_transitions 参数说明：
# 指定条件随机场CRF是否生成训练数据中甚至没有出现的转移特征（即负转移特征）。
# 如果为True，CRF将生成关联所有可能标签对的转移特征
crf.fit(X_train, y_train)

可能出现问题：

2.6、测试数据预测

1
2
3
4
5
6
7
8
y_pred = crf.predict(X_test)
print('条件随机场实体命名准确率是：',crf.score(X_test,y_test))
display(y_pred[:2],y_test[:2])
'''
条件随机场实体命名准确率是： 0.971455184056818
[['B-LOC', 'I-LOC', 'O', 'O', 'O', 'O', 'B-ORG', 'O', 'O'], ['O']]
[['B-LOC', 'I-LOC', 'O', 'O', 'O', 'O', 'B-ORG', 'O', 'O'], ['O']]
'''
]]> <h3 id="1、条件随机场CRF概述">1、条件随机场CRF概述</h3> <p>将之前所有的观测作为未来预测的依据是<strong>不现实的</strong>，因为其复杂度会随着观测数量的增加而无限制地增长。因此，就有了马尔科夫模型，即假定<strong>未来的预测仅与最近 贝叶斯网络 http://git.molittle.site/posts/64831aee.html 2025-06-10T05:49:32.000Z 2025-07-25T14:43:09.416Z 1、概率图模型概述

概率图模型算法往往应用于NLP自然语言处理领域。

当然很多传统机器学习的算法也常用于 NLP 的任务。例如，用朴素贝叶斯进行文本分类、用 SVM 进行语义角色标注，虽然它们在某些 NLP 任务中都实现了很好的效果，但它们都相互独立， 没有形成体系。

随着近些年对智能推理和认知神经学的深入研究，人们对大脑和语言的内在机制了解得越来越多，也越来越能从更高层次上观察和认识自然语言，由此形成一套完整的算法体系。目前最流行的算法思想包含如下两大流派：

  • 基于概率论和图论的概率图模型
  • 基于人工神经网络的深度学习理论

2、贝叶斯

2.1、贝叶斯案例一

一个例子，现分别有 A、B 两个容器，在容器 A 里分别有 7 个红球和 3 个白球，在容器 B 里有 1 个红球和 9 个白球，现已知从这两个容器里任意抽出了一个球，且是红球，问这个红球是来自容器 A 的概率是多少?

2.2、贝叶斯案例二

例如：一座别墅在过去的 20 年里一共发生过 2 次被盗，别墅的主人有一条狗，狗平均每周晚上叫 3 次，在盗贼入侵时狗叫的概率被估计为 0.9，问题是：在狗叫的时候发生入侵的概率是多少？

答案

3、朴素贝叶斯

举个例子，大学的时候，某男生经常去007自习室上晚自习，发现他喜欢的那个女生也常去那个自习室，心中窃喜，于是每天买点好吃的在那个自习室蹲点等她来，可是人家女生不一定每天都来，眼看天气渐渐炎热，自习室又不开空调，如果那个女生没去自习室，该男生也就不去，每次男生鼓足勇气说：“嘿，你明天还来不？”,“啊，不知道，看情况”。

然后该男生每天就把她去自习室与否以及一些其他情况做一下记录，用Y表示该女生是否去自习室，即Y={去，不去}，X是跟去自习室有关联的一系列条件，比如当天上了哪门主课，蹲点统计了一段时间后，该男生打算今天不再蹲点，而是先预测一下她会不会去，现在已经知道了今天上了常微分方程这门主课，于是计算P(Y=去|常微分方程)与P(Y=不去|常微分方程)，看哪个概率大，如果P(Y=去|常微分方程) >P(Y=不去|常微分方程)，那这个男生不管多热都屁颠屁颠去自习室了，否则就不去自习室受罪了。

P(Y=去|常微分方程)的计算可以通过贝叶斯公式进行计算，公式如下：

<P(Y=去∣常微分方程)=P(常微分方程∣Y=去)P(Y=去)P(常微分方程)\rm P(Y=去|常微分方程) = \frac{P(常微分方程|Y=去)P(Y=去)}{P(常微分方程)}​​

后来他发现还有一些其他条件可以挖，比如当天星期几、当天的天气，统计了一段时间后，该男子一计算，发现不好算了，因为总结历史的公式：

P(Y∣X)=P(Y∣X(1),X(2),…,X(n))P(Y|X) = P(Y|X^{(1)},X^{(2)},…,X^{(n)})

这里n = 3，x(1)表示主课，x(2)表示天气，x(3)表示星期几，Y仍然是{去，不去}，现在主课有8门，天气有晴、雨、阴三种，那么总共需要估计的参数有8×3×7×2=336个，每天只能收集到一条数据，那么等凑齐336条数据，黄花菜都凉了，男生大呼不妙！

于是做了一个独立性假设，假设这些影响她去自习室的因素是独立互不相关的！

有了这个独立假设后，需要估计的参数就变为，(8+3+7)×2 = 36个了，而且每天收集的一条数据，可以提供3个参数，这样该男生就预测越来越准了，天下武功唯快不破！迎娶白富美，全靠数学算！

P(Y∣X)=P(Y∣X(1),X(2),…,X(n))=∏i=1nP(Y∣X(i))\begin{aligned}\rm P(Y|X) &= P(Y|X^{(1)},X^{(2)},…,X^{(n)})\\\\&=\prod\limits_{i=1}^{n}P(Y|X^{(i)})\end{aligned}

4、朴素贝叶斯实例讲解

详情参考本人博客文章

5、朴素贝叶斯模型介绍

5.1、高斯分布朴素贝叶斯

高斯分布朴素贝叶斯------>正太分布

概率密度公式：

f(x∣μ,σ2)=12πσe−(x−μ)22σ2f(x|\mu,\sigma^2) = \frac{1}{\sqrt{2\pi}\sigma}e^{-\frac{(x - \mu)^2}{2\sigma^2}}
f(x)表示事件的概率分布

5.2、伯努利分布朴素贝叶斯

伯努利分布又叫做0-1分布，指一次随机试验，结果只有两种。也就是一个随机变量的取值只有0和1。

记为: 0-1分布 或B(1,p)，其中 p 表示一次伯努利实验中结果为正或为1的概率。

假设你要生孩子，生男孩子概率p，生女孩纸概率1-p

伯努利实验：例如，生一次孩子

伯努利分布：生一次孩子，生男孩子概率为p,生女孩纸概率1-p，这个就是伯努利分布

f(x∣p)={pxq1−x,x=0,1; 0,x≠0;f(x|p) = \left \{\begin{aligned} &p^xq^{1-x}, \quad & x = 0,1;  \\ &0,\quad &x \neq 0 ; \end{aligned}\right.​​​​​​​​​​​​

伯努利实验就是做一次服从伯努利概率分布的事件，它发生的可能性是p，不发生的可能性是1-p。

由伯努利分布延伸到二项分布，二项分布是多次伯努利分布实验的概率分布。

以抛硬币举例，在抛硬币事件当中，每一次抛硬币的结果是独立的，并且每次抛硬币正面朝上的概率是恒定的，所以单次抛硬币符合伯努利分布。我们假设硬币正面朝上的概率是p，那么反面朝上的概率是q=(1-p)。我们重复抛n次硬币，其中有k项正面朝上的事件，就是二项分布：

<P(X=k)=Cnkpkqn−k=n!(n−k)!k!pkqn−k\rm \begin{aligned}P(X = k) &= C^k_np^kq^{n-k}\\\\&=\frac{n!}{(n-k)!k!}p^kq^{n-k}\end{aligned}

5.3、多项式分布朴素贝叶斯

多项分布是在二项分布的基础上进一步的拓展。

以掷色子为例，在掷色子实验中可能出现的结局是：1,2,3,4,5,6（6标记为k，便于书写公式），分别记为变量X1、X2、…、XkX_1、X_2、…、X_k​，它们的概率分布分别是p1，p2，…，pkp_1，p_2，…，p_k​。那么在n次实验的结果中，1出现 n1n_1​ 次、2出现 n2n_2​ 次、…、6出现 nkn_k​ 次，这种事件的出现概率P有下面公式：

<P(X1=n1,…，Xk=nk)=n!n1!⋯nk!p1n1⋯pknk,∑i=1kni=nP(X_1 = n_1,…，X_k = n_k) = \frac{n!}{n_1!\cdots n_k!}p_1^{n_1} \cdots p_k^{n_k},\sum\limits_{i=1}^kn_i = n

另一种写法：

<P(X1=n1,…，Xk=nk)=n!∏i=1kpinini!,∑i=1kni=nP(X_1 = n_1,…，X_k = n_k) = n!\prod\limits_{i=1}^k\frac{p_i^{n_i}}{n_i!},\sum\limits_{i=1}^kn_i = n

6、朴素贝叶斯模型使用

使用正太分布数据，鸢尾花作为示例（鸢尾花是自然界的植物，其自身特征数据是正态分布的~）

6.1、数据加载
1
2
3
4
5
import numpy as np
from sklearn import datasets
from sklearn.naive_bayes import GaussianNB,BernoulliNB,MultinomialNB
from sklearn.model_selection import train_test_split
X,y = datasets.load_iris(return_X_y=True)
6.2、高斯分布朴素贝叶斯表现
1
2
3
4
5
6
7
8
9
10
score = 0
model = GaussianNB()
for i in range(100):
    X_train,X_test,y_train,y_test = train_test_split(X,y)
    model.fit(X_train,y_train)
    score += model.score(X_test,y_test)/100
print('高斯朴素贝叶斯模型平均预测准确率：',score)
'''
高斯朴素贝叶斯模型平均预测准确率： 0.9557894736842099
'''
6.3、伯努利分布朴素贝叶斯表现
1
2
3
4
5
6
7
8
9
10
score = 0
model = BernoulliNB()
for i in range(100):
    X_train,X_test,y_train,y_test = train_test_split(X,y)
    model.fit(X_train,y_train)
    score += model.score(X_test,y_test)/100
print('伯努利朴素贝叶斯模型平均预测准确率：',score)
'''
伯努利朴素贝叶斯模型平均预测准确率： 0.26105263157894737
'''
6.4、多项式分布朴素贝叶斯表现
1
2
3
4
5
6
7
8
9
10
score = 0
model = MultinomialNB()
for i in range(100):
    X_train,X_test,y_train,y_test = train_test_split(X,y)
    model.fit(X_train,y_train)
    score += model.score(X_test,y_test)/100
print('多项式朴素贝叶斯模型平均预测准确率：',score)
'''
多项式朴素贝叶斯模型平均预测准确率： 0.8255263157894736
'''

7、文本分类

文本分类的结构化方法就是 one-hot 表达模型。它是最直观，也是目前为止最常用的词表示方法，虽然越来越多的实践已经证明，这种模型存在局限性，但它仍在文本分类中得到广泛应用。

假设把语料库中的所有词都收集为一个词典 D，词典容纳了语料库中所有句子的词汇。

One-hot 方法就是把每个词表示为一个长长的向量。这个向量的维度是词典大小，其中绝大多数元素为 0，只有一个维度的值为 1。这个维度就代表了当前的词。

7.1、英文one-hot编码

文本一：My dog ate my homework；

文本二：My cat ate the fish；

文本三：Precious things are very few in the world,that is the reason there is only one you!

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
import jieba
import numpy as np
data = ['My dog ate my homework.','My cat ate the fish.',
        'Precious things are very few in the world,that is the reason there is only one you!']

result = []
for s in data:
    result.extend([i for i in jieba.lcut(s) if i not in [' ',',','.','!']])
result = np.array(result)

result = np.unique(result)
print(result)
for s in data:
    word_embedding = [(i == result).astype(np.int8) for i in jieba.lcut(s) if i not in [' ',',','.','!']]
    print(np.array(word_embedding))
    
'''
['My' 'Precious' 'are' 'ate' 'cat' 'dog' 'few' 'fish' 'homework' 'in' 'is'
 'my' 'one' 'only' 'reason' 'that' 'the' 'there' 'things' 'very' 'world'
 'you']
[[1 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 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 1 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 1 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0]]
'''
7.2、中文one-hot编码

s1 = ‘喜欢上一个人’

s2 = ‘尼姑亲吻了和尚的嘴唇’

s3 = ‘老师你教的都是没有的东西’

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import jieba
import numpy as np
data = ['喜欢上一个人','尼姑亲吻了和尚的嘴唇','老师你教的都是没有的东西']

result = []
for s in data:
    result.extend([i for i in jieba.lcut(s)])
result = np.array(result)

result = np.unique(result)
print(result)
for s in data:
    word_embedding = [(i == result).astype(np.int8) for i in jieba.lcut(s) if i not in [' ',',','.','!']]
    print(np.array(word_embedding))
    
'''
['一个' '上' '东西' '了' '亲吻' '人' '你' '和尚' '喜欢' '嘴唇' '尼姑' '教' '是' '没有' '的' '老师'
 '都']
[[0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0]
 [0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0]]
'''
7.3、TF-IDF
7.3.1、词频-逆向文件频率介绍

TF-IDF（term frequency–inverse document frequency，词频-逆向文件频率）是一种用于信息检索（information retrieval）与文本挖掘（text mining）的常用加权技术。

TF-IDF是一种统计方法，用以评估某字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。

TF-IDF的主要思想是：如果某个单词在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。

7.3.2、词频TF计算

**词频（TF）**表示词条（关键字）在文本中出现的频率。

TF=词条v出现的次数总词条数目\rm TF = \frac{词条v出现的次数}{总词条数目}

7.3.3、逆向文件频率IDF计算

逆向文件频率 (IDF) ：某一特定词语的IDF，可以由总文件数目除以包含该词语的文件的数目，再将得到的商取对数得到。

如果包含词条t的文档越少, IDF越大，则说明词条具有很好的类别区分能力。

IDF=log∣D∣∣{j:ti∈dj}∣\rm IDF = log\frac{|D|}{|\{j:t_i \in d_j\}|}

7.3.4、TF-IDF计算

某一特定文件内的高词语频率，以及该词语在整个文件集合中的低文件频率，可以产生出高权重的TF-IDF。因此，TF-IDF倾向于过滤掉常见的词语，保留重要的词语。

TF−IDF=TF×IDF\rm TF-IDF = TF \times IDF

7.3.5、TF-IDF算例演示

有很多不同的数学公式可以用来计算TF-IDF。词频 (TF) 是一词语出现的次数除以该文件的总词语数。假如一篇文件的总词语数是100个，而词语“Python”出现了5次，那么“Python”一词在该文件中的词频就是3/100=0.05。一个计算文件频率 (IDF) 的方法是文件集里包含的文件总数除以测定有多少份文件出现过“Python”一词。所以，如果“Python”一词在1000份文件出现过，而文件总数是10000000份的话，其逆向文件频率就是 lg(10000000 / 1000)=4。最后的TF-IDF的分数为0.05 * 4=0.2。

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
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
import jieba
import numpy as np

data = np.array(['政治 历史 地理 语文 化学',
                 'Python 计算机 语文 英语 数学'])
# 词频统计
vectorizer = CountVectorizer()
# tf-idf权值计算
tf_idf_transformer = TfidfTransformer()
# 对样本进行转换
tf_idf = tf_idf_transformer.fit_transform(vectorizer.fit_transform(data))
# 数据提取
tf_idf_weight = tf_idf.toarray()
vocabulary = vectorizer.vocabulary_
vocabulary = sorted( vocabulary.items(),key = lambda x:x[1],reverse = False)
display(vocabulary)
display(tf_idf_weight)
'''
[('python', 0),
 ('化学', 1),
 ('历史', 2),
 ('地理', 3),
 ('政治', 4),
 ('数学', 5),
 ('英语', 6),
 ('计算机', 7),
 ('语文', 8)]
array([[0.        , 0.47107781, 0.47107781, 0.47107781, 0.47107781,
        0.        , 0.        , 0.        , 0.33517574],
       [0.47107781, 0.        , 0.        , 0.        , 0.        ,
        0.47107781, 0.47107781, 0.47107781, 0.33517574]])
'''

8、垃圾短信分类项目实战

8.1、数据加载与介绍
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np
import pandas as pd
from sklearn.naive_bayes import GaussianNB,BernoulliNB,MultinomialNB
from sklearn.model_selection import train_test_split
from scipy import sparse # 稀松矩阵
# feature_selection 特征选择！
# feature_extraction 特征提取，萃取
# 土壤中，炼铁，这个过程类比 萃取
# 统计词频！通过词频，判断类别，判断短信是否是垃圾短信
# free、phone、获奖、优惠
from sklearn.feature_extraction.text import CountVectorizer,TfidfTransformer
# 短信数据
sms = pd.read_csv('./自动识别垃圾短信.csv',sep = '\t',header= None)
sms.rename({0:'label',1:'message'},axis = 1,inplace = True)
display(sms.shape,sms.head()) #文本数据无法直接建模
8.2、文本数据处理
1
2
3
4
5
6
cv = CountVectorizer()# stop-words 停用词，英文中的标点符号，对分类作用不大
# 主要目的，节省内存空间
# 量化
X = cv.fit_transform(sms['message'])
display(X)
print(X)

稀松矩阵介绍

1
2
3
4
5
6
7
8
9
# scipy中提供了方法
# 稀松矩阵、稠密矩阵 对比
a = np.random.randint(0,10,size = (1000,5))
a[a >=3] = 0
np.savez('稠密矩阵.npz',a) # 20.3kb
s = sparse.csc_matrix(a)
sparse.save_npz('稀松矩阵.npz',s) # 2.84kb
display(a,s)
print(s)

TF-IDF转换

1
2
3
4
5
6
# 此时X是稀松矩阵
# 稀松矩阵也可以进行拆分
tf_idf = TfidfTransformer()
X = tf_idf.fit_transform(X)
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.2,random_state = 1187)
X_train
8.3、数据建模评估
1
2
3
4
5
6
7
8
%%time
gNB = GaussianNB() # 高斯分布，是正太分布，数据属性必须是稠密矩阵
gNB.fit(X_train.toarray(),y_train)
print('高斯分布',gNB.score(X_test.toarray(),y_test))
'''
高斯分布 0.8869955156950673
Wall time: 717 ms
'''
1
2
3
4
5
6
7
8
9
%%time
# 稀松矩阵，计算优势，内存中占有量很小
bNB = BernoulliNB() # 二项分布，数据可以稀松的，准确率提升了很多，计算时间大大缩短
bNB.fit(X_train,y_train)
print('伯努利：',bNB.score(X_test,y_test))
'''
伯努利： 0.9730941704035875
Wall time: 13 ms
'''
1
2
3
4
5
6
7
8
%%time
mNB = MultinomialNB()
mNB.fit(X_train,y_train)
print('多项式分布：',mNB.score(X_test,y_test))
'''
多项式分布： 0.95695067264574
Wall time: 15 ms
'''
8.5、构建新短信预测
1
2
3
4
5
6
7
8
9
10
X_test = ['Your free ringtone is waiting to be collected. Simply text the password "MIX" to 85069 to verify.I see the letter B on my car Please call now 08000930705 for delivery tomorrow',
          'Precious things are very few in the world,that is the reason there is only one you',
          "GENT! We are trying to contact you. Last weekends draw shows that you won a £1000 prize GUARANTEED. U don't know how stubborn I am. Congrats! 1 year special cinema pass for 2 is yours.",
          'Congrats! 1 year special cinema pass for 2 is yours. call 09061209465 now! C Suprman V, Matrix3, StarWars3, etc all 4 FREE! bx420-ip4-5we. 150pm. Dont miss out!']

X_test = tf_idf.transform(cv.transform(X_test))
bNB.predict(X_test)
'''
array(['spam', 'ham', 'spam', 'spam'], dtype='<U4')
'''

9、新闻类别划分

9.1、加载数据（联网国外下载）
1
2
3
4
5
6
7
8
from sklearn.naive_bayes import GaussianNB,BernoulliNB,MultinomialNB
from sklearn import datasets
# countVectorizer词频 
# tf-idf term frequency（词频） inverse document frequency（你文本词频） + 权重
from sklearn.feature_extraction.text import TfidfVectorizer,CountVectorizer,ENGLISH_STOP_WORDS
from sklearn.model_selection import train_test_split
# 会存储到本地文件
news = datasets.fetch_20newsgroups(subset='all',remove=('headers', 'footers', 'quotes'))
9.2、文本数据转换
1
2
3
4
5
6
7
'''Convert a collection of raw documents to a matrix of TF-IDF features.
Equivalent to :class:`CountVectorizer` followed by
:class:`TfidfTransformer`.'''
tf_idf = TfidfVectorizer(stop_words=ENGLISH_STOP_WORDS)
X_tf_idf = tf_idf.fit_transform(X)
X_tf_idf
X_train,X_test,y_train,y_test = train_test_split(X_tf_idf,y,test_size = 0.2)
9.3、数据建模
1
2
3
4
5
6
7
8
%%time
bNB = BernoulliNB()
bNB.fit(X_train,y_train)
bNB.score(X_test,y_test)
'''
Wall time: 18.9 ms
0.7553191489361702
'''
1
2
3
4
5
6
7
8
%%time
mNB = MultinomialNB()
mNB.fit(X_train,y_train)
mNB.score(X_test,y_test)
'''
Wall time: 11 ms
0.8337765957446809
'''
1
2
3
4
5
6
7
8
%%time
gNB = GaussianNB()
gNB.fit(X_train.toarray(),y_train)
gNB.score(X_test.toarray(),y_test)
'''
Wall time: 2.66 s
0.8125
'''

10、贝叶斯网络

10.1、朴素贝叶斯与贝叶斯网络

朴素贝叶斯可以看做是贝叶斯网络的特殊情况：即该网络中无边，各个节点都是独立的（前提是独立性假设）。

那么，当朴素贝叶斯中的假设：独立同分布不成立时，应该如何解决呢？可以使用贝叶斯网络。

贝叶斯网络借助有向无环图来刻画属性之间的依赖关系，并使用条件概率表来描述属性的联合概率分布。

10.2、贝叶斯网络定义

贝叶斯网络(Bayesian network)，又称信念网络(Belief Network)，或有向无环图模型(directed acyclic graphical model)，是一种概率图模型，于1985年由Judea Pearl首先提出。它是一种模拟人类推理过程中因果关系的不确定性处理模型，其网络拓朴结构是一个有向无环图(DAG)。

10.3、贝叶斯网络三种结构
形式一：head-to-head

上图概率公式如下：P(a,b,c) = P(a) * P(b) * P(c|a,b)。

在 c 未知的条件下，a、b被阻断(blocked)，是独立的，称之为head-to-head条件独立。也就是a和b符合独立性假设。

形式二：tail-to-tail

  1. 在 c 未知的时候，有：P(a,b,c)=P© * P(a|c) * P(b|c)，此时，没法得出 P(a,b) = P(a) * P(b)，

即 c 未知时，a、b 不独立。

  1. 在 c 已知的时候，有：P(a,b|c)=P(a,b,c) / P©，然后将 P(a,b,c)=P© * P(a|c) * P(b|c)带入

式子中，得到：P(a,b|c)=P(a,b,c) / P© = P© * P(a|c) * P(b|c) / P© = P(a|c) * P(b|c)，即 c

已知时，a、b 独立。

形式三：head-to-tail

  1. c 未知时，有：P(a,b,c)=P(a) * P(c|a) * P(b|c)，但无法推出 P(a,b) = P(a) * P(b)，即 c 未知

时，a、b 不独立。

  1. c 已知时，有：P(a,b|c)=P(a,b,c) / P©，且根据 P(a,c) = P(a) * P(c|a) = P© * P(a|c)，可化

    简得到：

    P(a,b|c) =P(a,b,c) / P©

    ​= P(a) * P(c|a) * P(b|c) / P©

    ​=P(a,c) * P(b|c) / P©

    ​=P(a|c) * P(b|c)

    所以，在 c 给定的条件下，a，b 被阻断(blocked)，是独立的，称之为 head-to-tail

    条件独立。

    拓展一下，head-to-tail 其实就是一个链式网络，如下图所示：

    根据之前对head-to-tail的讲解，我们已经知道，在XiX_i给定的条件下，Xi+1X_{i+1}的分布和X1,X2…Xi−1X_1,X_2…X_{i-1}条件独立。意味着啥呢？意味着：Xi+1X_{i+1}的分布状态只和XiX_i有关，和其他变量条件独立。通俗点说，当前状态只跟上一状态有关，跟之前的状态无关。这种顺次演变的随机过程，就叫做马尔科夫链（Markov chain）。且有：

P(Xn+1∣X0,X1,⋯ ,Xn)=P(Xn+1∣Xn)P(X_{n+1}|X_0,X_1,\cdots,X_n) = P(X_{n + 1}|X_n)

朴素贝叶斯可以看做是贝叶斯网络的特殊情况：即该网络中无边，各个节点都是独立的。 朴素贝叶斯朴素在哪里呢？ 一个特征出现的概率与其他特征（条件）独立！

10.4、贝叶斯网络实例

有如下贝叶斯网络：

其中，各个单词、表达式表示的含义如下：

  • smoking 表示吸烟，其概率用 P(S) 表示，lung Cancer 表示肺癌，一个人在吸烟的情况下得肺癌的概率用P(C|S) 表示，X-ray 表示需要照医学上的 X 光，肺癌可能会导致需要照 X 光，吸烟也有可能会导致需要照 X 光（所以 smoking 也是 X-ray 的一个因素），所以，因吸烟且得肺癌而需要照X光的概率用 P(X|C,S) 表示。
  • Bronchitis 表示支气管炎，一个人在吸烟的情况下得支气管炎的概率用 P(B|S)，Dyspnoea 表示呼吸困难，支气管炎可能会导致呼吸困难，肺癌也有可能会导致呼吸困难（所以 lung Cancer 也是Dyspnoea的一个因素），因吸烟且得了支气管炎导致呼吸困难的概率用P(D|S,B)表示。

lung Cancer 简记为 C，Bronchitis 简记为 B，Dyspnoea 简记为 D，且 C = 0 表示 lung Cancer 不发生的概率，C = 1表示 lung Cancer 发生的概率，其他含义类似。

10.5、概率图模型

概率图模型是一类用图形模式表达基于概率相关关系的模型的总称。概率图模型结合概率论与图论的知识，利用图来表示与模型有关的变量的联合概率分布。近10年它已成为不确定性推理的研究热点，在人工智能、机器学习和计算机视觉等领域有广阔的应用前景。

根据是否是有向图，可以分为有向图模型和无向图模型。
有向图模型（又称为贝叶斯网络），例如：隐马尔科夫模型（Hidden Markov Model，HMM）
无向图模型（又称为马尔科夫网络），例如：条件随机场（Conditional Random Fields，CRF）

后面课程中会，进行介绍说明。

]]> <h3 id="1、概率图模型概述">1、概率图模型概述</h3> <p>概率图模型算法往往应用于NLP自然语言处理领域。</p> <p>当然很多传统机器学习的算法也常用于 NLP 的任务。例如，用朴素贝叶斯进行文本分类、用 SVM 进行语义角色标注，虽然它们在某些 NLP 任务 隐马尔科夫模型HMM http://git.molittle.site/posts/5f267e56.html 2025-06-10T05:49:32.000Z 2025-06-10T12:38:41.718Z 1、马尔科夫链

有向图模型（贝叶斯网络）：用有向图表示变量间的依赖关系；

无向图模型（马尔可夫网）：用无向图表示变量间的相关关系。

HMM 就是贝叶斯网络的一种–虽然它的名字里有和"马尔可夫网"一样的马尔可夫。

对变量序列建模的贝叶斯网络又叫动态贝叶斯网络。HMM 就是最简单的动态贝叶斯网络。

注意，马尔可夫过程其原始模型是马尔可夫链。该过程具有如下特性：在已知系统当前状态的条件下，它未来的演变不依赖于过去的演变。也就是说，一个马尔可夫过程可以表示为系统在状态转移过程中，第 T+1 次结果只受第 T 次结果的影响，即只与当前状态有关，而与过去状态，即与系统的初始状态和此次转移前的所有状态无关。

上图就是一个非常简单的马尔可夫链。两个节点分别表示睡和哭。几条边表示节点之间的转移概率。

睡之后，0.7 的可能又接着睡，只有 0.3 的可能变成哭。而哭之后，0.9 的可能是睡，也就有 0.1 的可能接着哭。

假设这是某个孩子的预报模型（这个孩子就只有哭和睡），则下一个状态只和上一个状态有关。和之前是在哭还是睡的状态没有关系。那么我们只要知道现在的状态，就可以推测接下来是睡还是哭的可能性了。

由马尔科夫链演化而成了隐含马尔可夫模型（Hidden Markov Model, HMM）！

2、HMM概述

2.1、HMM模型介绍

隐马尔科夫模型（Hidden Markov Model，以下简称HMM）是比较经典的机器学习模型了，它在语言识别，自然语言处理，模式识别等领域得到广泛的应用。

当然，随着目前深度学习的崛起，尤其是RNN，LSTM等神经网络序列模型的火热，HMM的地位有所下降。

但是作为一个经典的模型，学习HMM的模型和对应算法，对我们解决问题建模的能力提高以及算法思路的拓展还是很好的。

2.2、HMM模型应用

首先我们来看看什么样的问题解决可以用HMM模型。

使用HMM模型时我们的问题一般有这两个特征：

  • 我们的问题是基于序列的，比如时间序列，或者状态序列。

  • 我们的问题中有两类数据，一类序列数据是可以观测到的，即观测序列；而另一类数据是不能观察到的，即隐藏状态序列，简称状态序列。

有了这两个特征，那么这个问题一般可以用HMM模型来尝试解决。这样的问题在实际生活中是很多的。比如：我现在在打字写博客，我在键盘上敲出来的一系列字符就是观测序列，而我实际想写的一段话就是隐藏序列，输入法的任务就是从敲入的一系列字符尽可能的猜测我要写的一段话，并把最可能的词语放在最前面让我选择，这就可以看做一个HMM模型了。再举一个，我在和你说话，我发出的一串连续的声音就是观测序列，而我实际要表达的一段话就是状态序列，你大脑的任务，就是从这一串连续的声音中判断出我最可能要表达的话的内容。

2.3、HMM模型定义

HMM 是一个关于时序的概率模型，它的变量分为两组：

  • 状态变量{S1,S2,…,ST\rm S_1,S_2,…,S_T​​}，其中 ST\rm S_T​​，表示 T 时刻的系统状态；

  • 观测变量{O1,O2,…,OT\rm O_1,O_2,…,O_T​​}，其中 OT\rm O_T​ ，表示 T时刻的观测值。

状态变量和观测变量各自都是一个时间序列，每个状态/观测值都和一个时刻相对应，如下图所示：

一般假定状态序列HTH_T是隐藏的，不能被观测到的，因此状态变量是隐变量，这就是 HMM中的 hidden 的来源。

这个隐藏的，不可观测的状态序列是由一个马尔可夫链随机生成的，这是 HMM 中的第一个 M 的含义。

一条隐藏的马尔可夫链随机生成了一个不可观测的状态序列 state sequence，然后每个状态又对应生成了一个观测结果。这些观测值按照时序排列后就成了观测序列 observation sequence。这两个序列是一一对应的，每个对应的位置又对应着一个时刻。

一般而言，HMM 的状态变量取值是离散的，而观测变量的取值，则可以是离散的，也可以是连续的。不过为了方便讨论，也因为在大多数应用中观测变量也是离散的，因此，我们下面仅讨论状态变量和观测变量都是离散的情况。

3、HMM模型基本假设

HMM 的定义建立在两个假设之上：

3.1、假设1：

假设隐藏的马尔可夫链在任意时刻 t 的状态只依赖于前一个时刻(t-1)的状态，与其它时刻的状态及观测无关，也与时刻 t 无关。用公式表达就是：

P(St∣St−1,Ot−1,…,S1,O1)=P(St∣St−1)t=1,2,…,t\rm P(S_t|S_{t-1},O_{t-1},…,S_1,O_1) = P(S_t|S_{t-1}) \quad t = 1,2,…,t​​

这一假设又叫做齐次马尔可夫假设。

3.2、假设2：

假设任意时刻的观测只依赖于该时刻的马尔可夫链状态，与其它观测及状态无关。用公式表达就是：

P(Ot∣Sr,Or,…,St+1,Ot+1,St,Ot,St−1,Ot−1,…,S1,O1)=P(Ot∣St)\rm P(O_t|S_r,O_r,…,S_{t+1},O_{t+1},S_t,O_t,S_{t-1},O_{t-1},…,S_1,O_1) = P(O_t|S_t)

这叫观测独立性假设。

4、HMM模型解决三个问题

4.1、概率问题

概率计算问题，又称为评估问题。

已知信息：

  • 模型 λ=[A,B,Π]\lambda = [A,B,\Pi]​

  • 观测序列 {O1,O2,…,Or}\{O_1,O_2,…,O_r\}

求解目标：在给定模型 λ\lambda​ 下，计算观测序列 O 出现的概率：P(O∣λ)P(O|\lambda)​​ ?

下面举个语音识别的例子拿过来进行解释：

这里的任务呢就是我们语音输入得到可观察的序列，但是存在这样一个问题就是如果说话者普通话不标准或者环境干扰大，此时假如把ta发音te了，那么我们需要计算得到的可观察序列的概率有多大，而且我们把最大的那个当做本次的正确输入，例如如果本次输入的是下面一行的语音，但是通过解码后发现上面一行的概率最大， 因此就把上面的一行当做正确的语音输入。因此这就是第一个基本问题了，用处在语音识别中很明显。

4.2、预测问题

预测问题，又称为解码问题。

已知信息：

  • 模型 λ=[A,B,Π]\lambda = [A,B,\Pi]​

  • 观测序列 {O1,O2,…,Or}\{O_1,O_2,…,O_r\}

给出观测序列O和模型λ=[A,B,Π]\lambda = [A,B,\Pi]​，选择一个状态序列S，能最好的解释观测序列O。

求解目标：计算在给定模型 λ\lambda​​ 下，使已知观测序列 O 的条件概率 P(O|S)最大的状态序列{S1,S2,…,ST\rm S_1,S_2,…,S_T​​}，即给定观测序列，求最有可能与之对应的状态序列，使得该状态序列"最好地解释"观测序列。

下面举个语音识别的例子拿过来进行解释：

这里先默认语音的输入是正确的，如可观察序列是标准正确的，那么我们现在想通过可观察的序列即拼音，去寻找一个对应的文字（这就是语音识别的任务了），那么对应的句子那么多，哪个才是正确的呢？其实就是转态转移概率最大的那个句子就是最优的 ，如上图，隐藏层的第一行的汉子就是很好的"解释"了拼音且概率是最大的，而第二行就不是很好的解释，概率当然不是最大的，因此第二个基本问题就是这个意思，至于如何求这个概率，一般通过训练学习建模来构建算法模型。

4.3、学习问题

学习问题，又称为训练问题。

已知信息：

  • 观测序列 {O1,O2,…,Or}\{O_1,O_2,…,O_r\}​

求解目标：估计模型λ=[A,B,Π]\lambda = [A,B,\Pi]参数，使得该模型下观测序列概率P(O∣λ)P(O|\lambda)​​最大。也就是训练模型，使其最好地描述观测数据。

即根据最大似然估计调整模型λ=[A,B,Π]\lambda = [A,B,\Pi] 的参数，使得P(O∣λ)P(O|\lambda)​最大！

5、HMM模型算法示例

5.1、问题概述

比如，给定的HMM模型参数已知，求出三天观察是(Dizzy,Cold,Normal)的概率是多少？对应的HMM模型参数已知的意思，就是说的A转移概率分布矩阵(trainsition_probability)，B观测状态矩阵(emission_probability)，Pi初始状态分布矩阵是已经知道的。

由上图所示，也就是说，可以写成如下代码：

1
2
3
trainsition_probability = [[0.7,0.3],[0.4,0.6]]     
emission_probability = [[0.5,0.4,0.1],[0.1,0.3,0.6]]    
pi = [0.6,0.4]

在第一个问题中，我们需要求解出三天观察是(Dizzy,Cold,Normal)的概率是多少？
这里为了演示简单，我只求解出俩天观察为(Dizzy,Cold)的概率是多少！

5.2、概率计算

这个问题太好求解了，最暴力的方法就是将路径全部遍历一遍。下面尽可能通俗易懂的说明一下：
首先画出时间序列状态图如下：

下面，详细走一遍一条路径的暴力算法，这样既可以避开公式的晦涩，也不失正确性。其它路径完全类似
第一天为Healthy的概率为：

P(Healthy)=0.6\rm P(Healthy) = 0.6

在第一天为Healthy的基础上，观察为Dizzy的概率为：

P(Dizzy∣Healthy)=0.6×P(Health>>Dizzy)=0.6×0.1=0.06\rm P(Dizzy|Healthy) = 0.6 \times P(Health>>Dizzy) = 0.6 \times 0.1 = 0.06

然后求出在第一天为Healthy的基础上，并且第一天表现为Dizzy的前提下，第二天也为Healthy的概率为：

P(Healthy∣Healthy,Dizzy)=0.06×0.7=0.042\rm P(Healthy|Healthy,Dizzy) = 0.06 \times 0.7 = 0.042

上面求完的时候，代表下图中的红线已经转移完了。

继续，在前面的基础上，第二天观察为Cold的概率为：

$\rm P(Cold|(Healthy,Dizzy),(Healthy)) = 0.06 \times 0.7 \times 0.4 = 0.0168 $

上面所求即是在第一天隐含状态为Healthy和第二天隐含状态为Healthy的基础上，观察序列为Dizzy，Cold的概率。现在我们已经完成一条路径的完整结果了。

5.3、所有路径概率计算

那么同理，我们就可以求出其它三条路径。
（1）在第一天隐含状态为Healthy和第二天隐含状态为Fever的基础上，观察序列为Dizzy，Cold的概率

P(Cold∣(Healthy,Dizzy),(Fever))=0.06×0.3×0.3=0.0054 \rm P(Cold|(Healthy,Dizzy),(Fever)) = 0.06 \times 0.3 \times 0.3 = 0.0054 ​​​​

（2）在第一天隐含状态为Fever和第二天隐含状态为Healthy的基础上，观察序列为Dizzy，Cold的概率

P(Cold∣(Fever,Dizzy),(Healthy))=0.24×0.4×0.4=0.00384 \rm P(Cold|(Fever,Dizzy),(Healthy)) = 0.24 \times 0.4 \times 0.4 = 0.00384 ​​

（3）在第一天隐含状态为Fever和第二天隐含状态为Fever的基础上，观察序列为Dizzy，Cold的概0.24率

P(Cold∣(Fever,Dizzy),(Fever))=0.24×0.6×0.3=0.0432 \rm P(Cold|(Fever,Dizzy),(Fever)) = 0.24 \times 0.6 \times 0.3 = 0.0432 ​​​​

5.4、最终概率计算

前面提出的问题（俩天观察为(Dizzy,Cold)的概率是多少？）的结果就是将这四个结果相加起来就可以了。是不是很简单！

P(Dizzy,Cold)=0.0168+0.0054+0.003845+0.0432=0.069245\rm P(Dizzy,Cold) = 0.0168 + 0.0054 + 0.003845 + 0.0432 = 0.069245​

其实这个算法在现实中是不可行的。我给的例子由于是为了讲解容易，状态值和观察值都很小，但是实际中的问题，隐状态的个数是非常大的。

那么我们的计算量是不可以忍受的。

6、HMM模型前向算法示例

6.1、问题概述

这里我们用盒子与球的例子来显示前向概率的计算。

我们的观察集是：

V={红，白}，M=2\rm V = \{红，白\}，M = 2

我们的状态集合是：

Q={盒子一，盒子二，盒子三}，N=3\rm Q = \{盒子一，盒子二，盒子三\}，N= 3​

球的颜色观测序列

O={红，白，红}\rm O = \{红，白，红\}​

观察序列和状态序列的长度都是3。

初始状态分布为：

Π=[0.2,0.4,0.4]T\rm \Pi = [0.2,0.4,0.4]^T

状态转移概率分布矩阵为（三个盒子之间的状态转移、转变）：

A=[0.50.20.30.30.50.20.20.30.5]\rm A = \begin{bmatrix}0.5 & 0.2 & 0.3\\0.3 & 0.5 & 0.2\\0.2 & 0.3 & 0.5\end{bmatrix}​​​​

观测状态矩阵

B=[0.50.50.40.60.70.3]\rm B = \begin{bmatrix}0.5 & 0.5\\0.4 &0.6\\0.7&0.3\end{bmatrix}​​

6.2、时刻1（红球）

按照前向算法，首先计算时刻1三个状态的前向概率：

隐藏状态是盒子1的概率为：

α1(1)=π1b1(o1)=0.2×0.5=0.1\alpha_1(1) = \pi_1b_1(o_1) = 0.2 \times0.5 = 0.1​

隐藏状态是盒子2的概率为：

α1(2)=π2b2(o1)=0.4×0.4=0.16\alpha_1(2) = \pi_2b_2(o_1) = 0.4 \times 0.4 = 0.16​

隐藏状态是盒子3的概率为：

α1(3)=π3b3(o1)=0.4×0.7=0.28\alpha_1(3) = \pi_3b_3(o_1) = 0.4 \times 0.7 = 0.28​​

6.3、时刻2（白球）

现在，我们开始递推，首先递推时刻2三个状态的前向概率：

隐藏状态是盒子1的概率为：

α2(1)=[∑i=13α1(i)×ai1]×b1(o2)=[0.1∗0.5+0.16∗0.3+0.28∗0.2]∗0.5=0.077\begin{aligned}\alpha_2(1) &= [\sum\limits_{i=1}^3\alpha_1(i) \times a_{i1}] \times b_1(o_2) \\\\&= [0.1 * 0.5 + 0.16 * 0.3 + 0.28 * 0.2] * 0.5 = 0.077\end{aligned}​​

隐藏状态是盒子2的概率为：

α2(2)=[∑i=13α1(i)×ai2]×b2(o2)=[0.1∗0.2+0.16∗0.5+0.28∗0.3]∗0.6=0.1104\begin{aligned}\alpha_2(2) &= [\sum\limits_{i=1}^3\alpha_1(i) \times a_{i2}] \times b_2(o_2) \\\\&= [0.1 * 0.2 + 0.16 * 0.5 + 0.28 * 0.3] * 0.6 = 0.1104\end{aligned}​​

隐藏状态是盒子3的概率为：

α2(3)=[∑i=13α1(i)×ai3]×b3(o2)=[0.1∗0.3+0.16∗0.2+0.28∗0.5]∗0.3=0.0606\begin{aligned}\alpha_2(3) &= [\sum\limits_{i=1}^3\alpha_1(i) \times a_{i3}] \times b_3(o_2) \\\\&= [0.1 * 0.3 + 0.16 * 0.2 + 0.28 * 0.5] * 0.3 = 0.0606\end{aligned}​

6.4、时刻3（红球）

继续递推，现在我们递推时刻3三个状态的前向概率：

隐藏状态是盒子1的概率为：

α3(1)=[∑i=13α2(i)×ai1]×b1(o3)=[0.077∗0.5+0.1104∗0.3+0.0606∗0.2]∗0.5=0.04187\begin{aligned}\alpha_3(1) &= [\sum\limits_{i=1}^3\alpha_2(i) \times a_{i1}] \times b_1(o_3) \\\\&= [0.077 * 0.5 + 0.1104 * 0.3 + 0.0606 * 0.2] * 0.5 = 0.04187\end{aligned}

隐藏状态是盒子2的概率为：

α3(2)=[∑i=13α2(i)×ai2]×b2(o3)=[0.077∗0.2+0.1104∗0.5+0.0606∗0.3]∗0.4=0.035512\begin{aligned}\alpha_3(2) &= [\sum\limits_{i=1}^3\alpha_2(i) \times a_{i2}] \times b_2(o_3) \\\\&= [0.077 * 0.2 + 0.1104 * 0.5 + 0.0606 * 0.3] * 0.4 = 0.035512\end{aligned}

隐藏状态是盒子3的概率为：

α3(3)=[∑i=13α2(i)×ai3]×b3(o3)=[0.077∗0.3+0.1104∗0.2+0.0606∗0.5]∗0.7=0.05284\begin{aligned}\alpha_3(3) &= [\sum\limits_{i=1}^3\alpha_2(i) \times a_{i3}] \times b_3(o_3) \\\\&= [0.077 * 0.3 + 0.1104 * 0.2 + 0.0606 * 0.5] * 0.7 = 0.05284\end{aligned}​

6.5、最终概率计算

最终我们求出观测序列:O={红，白，红}的概率为：

P(O∣λ)=∑i=13α3(i)=0.04187+0.035512+0.05284=0.130222\rm \begin{aligned} P(O|\lambda) &= \sum\limits_{i=1}^3\alpha_3(i) \\\\&= 0.04187 + 0.035512 + 0.05284 \\\\&= 0.130222\end{aligned}​​

7、维特比算法

7.1、维特比算法概述

维特比算法是一个通用的解码算法，是基于动态规划的求序列最短路径的方法。

既然是动态规划算法，那么就需要找到合适的局部状态，以及局部状态的递推公式。在HMM中，维特比算法定义了两个局部状态用于递推。

第一个局部状态是在时刻 t 隐藏状态为 i 所有可能的状态转移路径 (i1,i2,…,it)(i_1,i_2,…,i_t)​​ 中的概率最大值。记为 δt(i)\delta_t(i):

δt(i)=max⁡i1,i2,…itP(it=i,i1,i2,…,it−1,ot,ot−1,…,o1∣λ),i=1,2,…,N\delta_t(i) = \max\limits_{i_1,i_2,…i_t}P(i_t = i,i_1,i_2,…,i_{t-1},o_t,o_{t-1},…,o_1|\lambda),\quad i = 1,2,…,N​

由δt(i)\delta_t(i)​ 的定义可以得到 δ\delta​ 的递推公式：

δt+1(i)=max⁡i1,i2,…it+1P(it+1=i,i1,i2,…,it,ot+1,ot,,…,o1∣λ)=max⁡1≤j≤N[δt(j)×aji]×bi(ot+1),i=1,2,…,N\begin{aligned}\delta_{t+1}(i) &= \max\limits_{i_1,i_2,…i_{t+1}}P(i_{t+1} = i,i_1,i_2,…,i_{t},o_{t+1},o_t,,…,o_1|\lambda)\\\\&=\max\limits_{1\le j \le N}[\delta_t(j) \times a_{ji}]\times b_i(o_{t+1}),\quad i = 1,2,…,N\end{aligned}​​​

第二个局部状态由第一个局部状态递推得到。

我们定义在时刻 t 隐藏状态为 i 的所有单个状态转移路径 (i1,i2,…,iN)(i_1,i_2,…,i_N)​ 中概率最大的转移路径中第 t−1 个节点的隐藏状态为 ψt(i)\psi_t(i)​​,其递推表达式可以表示为：

ψt(i)=argmax⁡1≤j≤N[δt−1(j)×aji]\psi_t{(i)} = arg \max\limits_{1 \le j \le N}[\delta_{t-1(j)\times a_{ji}}]​​

有了这两个局部状态，我们就可以从时刻0一直递推到时刻 T，然后利用 ψt(i)\psi_t(i) 记录的前一个最可能的状态节点回溯，直到找到最优的隐藏状态序列。

7.2、维特比算法流程

现在我们来总结下维特比算法的流程：

输入：HMM模型 λ=(A,B,Π)\lambda = (A,B,\Pi)​​ ，观测序列 O=(o1,o2,…,oT)O = (o_1,o_2,…,o_T)​​

输出：最有可能的隐藏状态序列 I∗=i1∗,i2∗,…,iT∗I^* = {i_1^*,i_2^*,…,i_T^*}​

1、初始化局部状态

δ1(i)=πi×bi(o1),i=1,2,…,N\delta_1(i) = \pi_i \times b_i(o_1),i = 1,2,…,N

ψ1(i)=0,i=1,2,…,N\psi_1(i) = 0,i = 1,2,…,N

2、进行动态规划递推时刻 t=2,3,…T 时刻的局部状态：

δt(i)=max⁡1≤j≤N[δt−1(j)×aji]×bi(ot),i=1,2,…,N\delta_t(i) = \max\limits_{1 \le j \le N}[\delta_{t-1}(j) \times a_{ji}] \times b_i(o_t),i = 1,2,…,N

ψt(i)=argmax⁡1≤j≤N[δt−1×aji],i=1,2,…,N\psi_t(i) = arg \max\limits_{1 \le j \le N}[\delta_{t-1} \times a_{ji}],i=1,2,…,N

3、计算时刻 T 最大的δT(i)\delta_T(i)，即为最可能隐藏状态序列出现的概率。计算时刻 T 最大的ψT(i)\psi_T(i)​，即为时刻 T 最可能的隐藏状态。

P∗=max⁡1≤j≤NδT(i)P^* = \max\limits_{1 \le j \le N}\delta_T(i)

iT∗=argmax⁡1≤j≤N[δT(i)]i_T^* = arg \max\limits_{1 \le j \le N}[\delta_T(i)]​

4、利用局部状态 ψ(i)\psi(i)​ 开始回溯。对于 t = T−1，T−2，…，1：

it∗=ψt+1(it+1∗)i^*_t = \psi_{t + 1}(i_{t + 1}^*)

最终得到最有可能的隐藏状态序列：

I∗=i1∗,i2∗,…,iT∗I^* = {i_1^*,i_2^*,…,i_T^*}

7.3、维特比算法示例

7.3.1、问题概述

这里我们用盒子与球的例子来显示前向概率的计算。

我们的观察集是：

V={红，白}，M=2\rm V = \{红，白\}，M = 2

我们的状态集合是：

Q={盒子一，盒子二，盒子三}，N=3\rm Q = \{盒子一，盒子二，盒子三\}，N= 3​

球的颜色观测序列

O={红，白，红}\rm O = \{红，白，红\}​

观察序列和状态序列的长度都是3。

初始状态分布为：

Π=[0.2,0.4,0.4]T\rm \Pi = [0.2,0.4,0.4]^T

状态转移概率分布矩阵为（三个盒子之间的状态转移、转变）：

A=[0.50.20.30.30.50.20.20.30.5]\rm A = \begin{bmatrix}0.5 & 0.2 & 0.3\\0.3 & 0.5 & 0.2\\0.2 & 0.3 & 0.5\end{bmatrix}​​​​

观测状态矩阵

B=[0.50.50.40.60.70.3]\rm B = \begin{bmatrix}0.5 & 0.5\\0.4 &0.6\\0.7&0.3\end{bmatrix}​​

7.3.2、时刻1（红球）

按照维特比算法，首先需要得到三个隐藏状态在时刻1时对应的各自两个局部状态，此时观测状态为1：

隐藏状态是盒子1的概率为：

δ1(1)=π1b1(o1)=0.2×0.5=0.1\delta_1(1) = \pi_1b_1(o_1) = 0.2 \times0.5 = 0.1​​

隐藏状态是盒子2的概率为：

δ1(2)=π2b2(o1)=0.4×0.4=0.16\delta_1(2) = \pi_2b_2(o_1) = 0.4 \times 0.4 = 0.16​​

隐藏状态是盒子3的概率为：

δ1(3)=π3b3(o1)=0.4×0.7=0.28\delta_1(3) = \pi_3b_3(o_1) = 0.4 \times 0.7 = 0.28​​​

ψ1(1)=ψ1(2)=ψ1(3)=0\psi_1(1) = \psi_1(2) = \psi_1(3) = 0​

7.3.3、时刻2（白球）

现在开始递推三个隐藏状态在时刻2时对应的各自两个局部状态，此时观测状态为2：

δ2(1)=max⁡1≤j≤3[δ1(j)×aj1]×b1(o2)=max⁡1≤j≤3[0.1×0.5,0.16×0.3,0.28×0.2]×0.5=0.028\begin{aligned}\delta_2(1) &= \max\limits_{1 \le j \le 3}[\delta_1(j)\times a_{j1}] \times b_1(o_2)\\\\&=\max\limits_{1 \le j \le 3}[0.1 \times 0.5,0.16 \times 0.3,0.28 \times 0.2] \times 0.5 \\\\&=0.028\end{aligned}​​

ψ2(1)=3\psi_2(1) = 3

δ2(2)=max⁡1≤j≤3[δ1(j)×aj2]×b2(o2)=max⁡1≤j≤3[0.1×0.2,0.16×0.5,0.28×0.5]×0.6=0.0504\begin{aligned}\delta_2(2) &= \max\limits_{1 \le j \le 3}[\delta_1(j)\times a_{j2}] \times b_2(o_2)\\\\&=\max\limits_{1 \le j \le 3}[0.1 \times 0.2,0.16 \times 0.5,0.28 \times 0.5] \times 0.6 \\\\&=0.0504\end{aligned}

ψ2(2)=3\psi_2(2) = 3

δ2(3)=max⁡1≤j≤3[δ1(j)×aj3]×b3(o2)=max⁡1≤j≤3[0.1×0.3,0.16×0.2,0.28×0.5]×0.6=0.042\begin{aligned}\delta_2(3) &= \max\limits_{1 \le j \le 3}[\delta_1(j)\times a_{j3}] \times b_3(o_2)\\\\&=\max\limits_{1 \le j \le 3}[0.1 \times 0.3,0.16 \times 0.2,0.28 \times 0.5] \times 0.6 \\\\&=0.042\end{aligned}

ψ2(3)=3\psi_2(3) = 3​

7.3.4、时刻3（白球）

继续递推三个隐藏状态在时刻3时对应的各自两个局部状态，此时观测状态为1：

δ3(1)=max⁡1≤j≤3[δ2(j)×aj1]×b1(o3)=max⁡1≤j≤3[0.028×0.5,0.0504×0.3,0.042×0.2]×0.5=0.00756\begin{aligned}\delta_3(1) &= \max\limits_{1 \le j \le 3}[\delta_2(j)\times a_{j1}] \times b_1(o_3)\\\\&=\max\limits_{1 \le j \le 3}[0.028 \times 0.5,0.0504 \times 0.3,0.042 \times 0.2] \times 0.5 \\\\&=0.00756\end{aligned}

ψ3(1)=2\psi_3(1) = 2​

δ3(2)=max⁡1≤j≤3[δ2(j)×aj2]×b2(o3)=max⁡1≤j≤3[0.028×0.2,0.0504×0.5,0.042×0.3]×0.4=0.01008\begin{aligned}\delta_3(2) &= \max\limits_{1 \le j \le 3}[\delta_2(j)\times a_{j2}] \times b_2(o_3)\\\\&=\max\limits_{1 \le j \le 3}[0.028 \times 0.2,0.0504 \times 0.5,0.042 \times 0.3] \times 0.4 \\\\&=0.01008\end{aligned}

ψ3(2)=2\psi_3(2) = 2​​

δ3(3)=max⁡1≤j≤3[δ2(j)×aj3]×b3(o3)=max⁡1≤j≤3[0.028×0.3,0.0504×0.2,0.042×0.5]×0.7=0.0147\begin{aligned}\delta_3(3) &= \max\limits_{1 \le j \le 3}[\delta_2(j)\times a_{j3}] \times b_3(o_3)\\\\&=\max\limits_{1 \le j \le 3}[0.028 \times 0.3,0.0504 \times 0.2,0.042 \times 0.5] \times 0.7 \\\\&=0.0147\end{aligned}

ψ3(3)=3\psi_3(3) = 3​​

7.3.5、状态回溯

此时已经到最后的时刻，我们开始准备回溯。

  • 此时最大概率为δ3(3)=0.0147\delta_3(3) = 0.0147​ ，从而得到 i3∗=3i_3^* = 3​ 。

it∗=ψt+1(it+1∗)i^*_t = \psi_{t + 1}(i_{t + 1}^*)

  • 由于ψ3(3)=3\psi_3(3) = 3​ ，所以 i2∗=3i_2^* = 3​
  • 由于ψ2(3)=3\psi_2(3) = 3 ，所以 i1∗=3i_1^* = 3

从而最终的最可能隐藏状态序列为：[3,3,3]，表示球的观测序列 O={红，白，红}\rm O = \{红，白，红\}​​ 最有可能出现的的盒子是：[盒子三，盒子三，盒子三]。

8、代码演练

8.1、参数估计问题

参数估计问题，也叫学习问题。已知观察序列，来对HMM模型的参数进行估计。

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
'''
下面抽取5次，得到已知的观察序列，
来对HMM的参数进行估计，即使用MultinomialHMM进行参数的训练
'''
import numpy as np
import hmmlearn.hmm as hmm

states = ['盒子1', '盒子2', '盒子3']
obs = ['红球', '白球'] # 0表示红球，1表示白球
n_states = len(states)
m_obs = len(obs)

model = hmm.MultinomialHMM(n_components=n_states, n_iter=10, tol=0.001,algorithm='map')
X2 = np.array([
    [0, 1, 0, 0, 1],
    [0, 0, 0, 1, 1],
    [1, 1, 0, 1, 0],
    [0, 1, 0, 1, 1],
    [0, 0, 0, 1, 0]
])
model.fit(X2)
print("输出根据数据训练出来的π")
print(model.startprob_.round(3))
print("输出根据数据训练出来的A")
print(model.transmat_.round(3))
print("输出根据数据训练出来的B")
print(model.emissionprob_.round(3))
# 每次运行结果可能会不同
'''
输出根据数据训练出来的π
[0.296 0.702 0.002]
输出根据数据训练出来的A
[[0.313 0.302 0.384]
 [0.293 0.272 0.435]
 [0.358 0.382 0.26 ]]
输出根据数据训练出来的B
[[0.648 0.352]
 [0.744 0.256]
 [0.298 0.702]]
'''

8.2、解码问题

已知观察序列，求什么样的隐藏状态序列最可能生成一个给定的观察序列

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
51
52
53
54
55
56
57
58
59
60
import numpy as np
import hmmlearn.hmm as hmm

# 首先定义变量
status = ['盒子1', '盒子2', '盒子3']   # 隐藏的状态集合
obs = ['红球', '白球']     # 观察值集合
n_status = len(status)    # 隐藏状态的长度
m_obs = len(obs)          # 观察值的长度

# 初始概率分布： π 表示初次抽时，抽到1盒子的概率是0.2，抽到2盒子的概率是0.4，抽到3盒子的概率是0.4
start_probability = np.array([0.2, 0.4, 0.4])   

# 状态转移概率矩阵 A[0][0]=0.5 表示当前我抽到1盒子，下次还抽到1盒子的概率是0.5
transition_probability = np.array([[0.5, 0.2, 0.3],
                                   [0.3, 0.5, 0.2],
                                   [0.2, 0.3, 0.5]])

# 观测概率矩阵 B：B[2][0]=0.7,表示第三个盒子抽到红球概率0.7，B[2][1]=0.3，表示第三个盒子抽到白球概率0.3
emission_probalitity = np.array([[0.5, 0.5],
                                 [0.4, 0.6],
                                 [0.7, 0.3]])

# 下面开始定义模型
'''
hmmlearn中主要有两种模型，分布为：GaussianHMM和MultinomialHMM；
如果观测值是连续的，那么建议使用GaussianHMM，否则使用MultinomialHMM

参数：
初始的隐藏状态概率π参数为: startprob；
状态转移矩阵A参数为: transmat;
状态和观测值之间的转移矩阵B参数为: 
emissionprob_(MultinomialHMM模型中)或者在GaussianHMM模型中直接给定均值(means)和方差/协方差矩阵(covars)

'''
# 观测值，球是红或者黑，是离散的，n_status隐藏状态的长度
model = hmm.MultinomialHMM(n_components=n_status)  
model.startprob_ = start_probability
model.transmat_ = transition_probability
model.emissionprob_ = emission_probalitity

'''
下面运行viterbi预测问题。已知观察序列（红球 白球 红球），
求什么样的隐藏状态序列（盒子2 盒子3 盒子2）最可能生成一个给定的观察序列。

status = ['盒子1', '盒子2', '盒子3']
obs = ['红球', '白球'] 
'''
se = np.array([[0, 1, 0]]).T   # （红球 白球 红球）
logprob, box_index = model.decode(se, algorithm='viterbi')
print("颜色:", end="")
print(" ".join(map(lambda t: obs[t], [0, 1, 0])))
print("盒子:", end="")
print(" ".join(map(lambda t: status[t], box_index)))
print("概率值:", end="")
print(np.exp(logprob)) # 这个是因为在hmmlearn底层将概率进行了对数化，防止出现乘积为0的情况
'''
颜色:红球 白球 红球
盒子:盒子3 盒子3 盒子3
概率值:0.014699999999999996
'''

8.3、股票走势预测

8.3.1、加载数据
1
2
3
4
5
6
7
8
9
import pandas as pd
import numpy as np
from hmmlearn.hmm import GaussianHMM
import warnings
warnings.filterwarnings('ignore')
 
data = pd.read_csv('apple_stock.csv')
print(data.shape)
data.head()
8.3.2、日期转换
1
2
3
4
# 日期格式转换
data['Date'] = pd.to_datetime(data['Date'], format = '%Y/%m/%d', errors = 'ignore')
data.info()
data.head()
8.3.3、数据提取
1
2
3
4
5
6
7
8
9
10
# 去除第一天的数据,因为第一天会被用来计算第二天的涨跌值特征，所以马尔可夫链实际是从第二天开始训练的。
close_v = data['Close'].values
volume = data['Volume'].values[1:]
 
# 计算数组中前后两个值差额
diff  = np.diff(close_v)
close_v = close_v[1:]
 
X = np.column_stack([diff,volume])
X.shape
8.3.4、算法建模

n_components 参数指定了使用3个隐藏层状态，表示股票：涨、平、跌三种状态

covariance_type定义了协方差矩阵类型为对角线类型，即每个特征的高斯分布有自己的方差参数，相互之间没有影响

n_iter参数定义了最大迭代次数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
model =  GaussianHMM(n_components=3, covariance_type='diag',n_iter=100000)
model.fit(X)
print('每个隐含层均值和方差数据：')
for i in range(model.n_components):
    print('第{0}号隐藏状态'.format(i))
    print('mean = ', model.means_[i])
    print('var = ', np.diag(model.covars_[i]))
    print('---------------')
    
'''
每个隐含层均值和方差数据：
第0号隐藏状态
mean =  [-1.14524842e-01  1.23845771e+08]
var =  [3.84678157e+00 2.24454700e+15]
---------------
第1号隐藏状态
mean =  [1.68138743e-01 2.79598061e+07]
var =  [1.00638562e+00 5.12991123e+13]
---------------
第2号隐藏状态
mean =  [5.04087051e-02 5.66296542e+07]
var =  [2.81382699e+00 2.27530289e+14]
---------------
'''

因为可见层输入采用了两个输入特征（涨跌幅、成交量），所以每个结点有两个元素，分别代表该状态的涨跌幅均值、成交量均值。

由于系统的目标预测涨跌幅，所以这里只关心第一个特征的均值，有如下结论：

  • 状态0的均值是-1.14524842e-01，约为-0.1145，认为该状态是跌。

  • 状态1的均值是1.68138743e-01，约为0.1681，认为该状态是涨。

  • 状态2的均值是5.04087051e-02，约为0.0504，认为该状态是平。

由涨跌幅特征的方差，可以得到的信息为：

  • 状态跌的方差为3.845，是三个状态中方差最大的，也就是说该状态的预测不是特别可信。

  • 状态**涨**的方差为1.006，是三个状态中方差最小的，也就是说该状态的预测非常可信。

  • 状态平的方差为2.814，可信居中。

8.3.5、状态转移
1
2
3
4
5
6
7
8
print('Transition matrix')
print(model.transmat_.round(3))
'''
Transition matrix
[[0.898 0.    0.102]
 [0.    0.915 0.085]
 [0.083 0.043 0.874]]
'''

第一行最大的数值是0.915，因此**跌倾向于保持自己的状态，即第二天仍旧为跌**。

第二行最大的数值是0.898，得知**涨后第二天倾向于变为涨**。

根据第三行转变状态最大数值0.874，平后第二天仍旧倾向于平。

]]> <h3 id="1、马尔科夫链">1、马尔科夫链</h3> <p>有向图模型（贝叶斯网络）：用有向图表示变量间的依赖关系；</p> <p>无向图模型（马尔可夫网）：用无向图表示变量间的相关关系。</p> <p>HMM 就是贝叶斯网络的一种–虽然它的名字里有和&quot;马尔可夫网 降维算法 http://git.molittle.site/posts/189a1a64.html 2025-06-10T04:49:32.000Z 2025-07-25T14:41:45.532Z [TOC]

相关背景

  • 在许多领域的研究与应用中，通常需要对含有多个变量的数据进行观测，收集大量数据后进行分析研究寻找规律。多变量大数据集无疑会为研究和应用提供丰富的信息，但是也在一定程度上增加了数据采集的工作量。更重要的是在很多情形下，多变量之间可能存在相关性，从而增加了问题分析的复杂性。如果分别对每个指标进行分析，分析往往是孤立的，不能完全利用数据中的信息，因此盲目减少指标会损失很多有用的信息，从而产生错误的结论。
  • 因此需要找到一种合理的方法，在减少需要分析的指标同时，尽量减少原指标包含信息的损失，以达到对所收集数据进行全面分析的目的。由于各变量之间存在一定的相关关系，因此可以考虑将关系紧密的变量变成尽可能少的新变量，使这些新变量是两两不相关的，那么就可以用较少的综合指标分别代表存在于各个变量中的各类信息。
  • 数据的形式是多种多样的，维度也是各不相同的，当实际问题中遇到很高的维度时，如何给他降到较低的维度上？进行属性选择，当然这是一种很好的方法，这里另外提供一种从高维特征空间向低纬特征空间映射的思路。

数据降维

  • 降维就是一种对高维度特征数据预处理方法。降维是将高维度的数据保留下最重要的一些特征，去除噪声和不重要的特征，从而实现提升数据处理速度的目的。在实际的生产和应用中，降维在一定的信息损失范围内，可以为我们节省大量的时间和成本。降维也成为应用非常广泛的数据预处理方法。
  • 数据降维，直观地好处是维度降低了，便于计算和可视化，其更深层次的意义在于有效信息的提取综合及无用信息的摈弃。
  • 三维变两维
  • 跟射人先射马，擒贼先擒王一样的道理。抓住主要的，忽略次要的。
  • 人的消化系统就是数据（食物）降维过程，变成基本的葡萄糖和氨基酸以及维生素。
  • 降维具有如下一些优点：
      1. 减少所需的存储空间
      1. 加快计算速度(例如在机器学习算法中)，更少的维数意味着更少的计算，并且更少的维数可以允许使用不适合大量维数的算法。
    • 3)去除冗余特征，例如在以平方米和平方公里在存储地形尺寸方面，两者一起用没有意义(数据收集有缺陷)。
      1. 将数据的维数降低到2D或3D可以允许我们绘制和可视化它，可能观察模式，给我们提供直观感受。
      1. 太多的特征或太复杂的模型可以导致过拟合。
      1. 较简单的模型在小数据集上有更强的鲁棒性

数据降维的方法

  • 主要的方法是线性映射和非线性映射方法两大类。
  • 线性映射方法的代表方法有：PCA（Principal Component Analysis），LDA（Discriminant Analysis）
  • 非线性映射方法的代表方法有：核方法（KernelPCA）、流形学习（ISOMap，LLE）
  • 非负矩阵分解（NMF）是在矩阵中所有元素均为非负数的约束条件之下的矩阵分解方法

PCA降维

  1. PCA（Principal Components Analysis）即主成分分析，是图像处理中经常用到的降维方法。它不仅仅是对高维数据进行降维，更重要的是经过降维去除了噪声，发现了数据中的模式。PCA把原先的n个特征用数目更少的m个特征取代，新特征是旧特征的线性组合，这些线性组合最大化样本方差，尽量使新的m个特征互不相关。

  2. PCA方法通过消除数据的相关性，找到一个空间，使得各个类别的数据在该空间上能够很好地分离。在下图中，有一些离散的二维分布点，其中棕色表示一类集合，黄色表示另一类集合，假设这两个类别可以用特征X和特征Y进行描述，由图可知，在X轴和Y轴上这两个类别的投影是重叠的，表明这些点的两个特征X和Y没有表现出突出的识别性。但是两个类的投影在Z轴上区分度较大，显示出很好的识别性。PCA就是这样的一个工具，它可以产生非常好的降维效果。

  3. PCA(Principal Component Analysis)，即主成分分析方法，是一种使用最广泛的数据降维算法。PCA的主要思想是将n维特征映射到k维上，这k维是全新的正交特征也被称为主成分，是在原有n维特征的基础上重新构造出来的k维特征。PCA的工作就是从原始的空间中顺序地找一组相互正交的坐标轴，新的坐标轴的选择与数据本身是密切相关的。其中，第一个新坐标轴选择是原始数据中方差最大的方向，第二个新坐标轴选取是与第一个坐标轴正交的平面中使得方差最大的，第三个轴是与第1,2个轴正交的平面中方差最大的。依次类推，可以得到n个这样的坐标轴。通过这种方式获得的新的坐标轴，我们发现，大部分方差都包含在前面k个坐标轴中，后面的坐标轴所含的方差几乎为0。于是，我们可以忽略余下的坐标轴，只保留前面k个含有绝大部分方差的坐标轴。事实上，这相当于只保留包含绝大部分方差的维度特征，而忽略包含方差几乎为0的特征维度，实现对数据特征的降维处理。

    思考：我们如何得到这些包含最大差异性的主成分方向呢？

    通过计算数据矩阵的协方差矩阵，然后得到协方差矩阵的特征值特征向量，选择特征值最大(即方差最大)的k个特征所对应的特征向量组成的矩阵。这样就可以将数据矩阵转换到新的空间当中，实现数据特征的降维。

    由于得到协方差矩阵的特征值特征向量有两种方法：特征值分解协方差矩阵、奇异值分解协方差矩阵，所以PCA算法有两种实现方法：基于特征值分解协方差矩阵实现PCA算法、基于SVD分解协方差矩阵实现PCA算法。

  4. pca降维原理
    4.1. 协方差和散度矩阵

    样本均值

    xˉ=1n∑i=1nxi\bar x = \frac{1}{n}\sum_{i=1}^nx_i

    样本方差

    S2=1n−1∑i=1n(xi−xˉ)2S^2 = \frac{1}{n-1}\sum_{i=1}^{n}(x_i - \bar x)^2

    样本X和样本Y的协方差

    Conv(X,Y)=E[(X−E(X))(Y−E(Y))]Conv(X,Y) = E[(X - E(X))(Y - E(Y))]

    ​$$=\frac{1}{n-1}\sum_{i=1}^n(x_i - \bar x)(y_i - \bar y)$$

    由上面的公式，我们可以得到以下结论：

    • 方差的计算公式是针对一维特征，即针对同一特征不同样本的取值来进行计算得到；而协方差则必须要求至少满足二维特征；方差是协方差的特殊情况。

    • 方差和协方差的除数是n-1,这是为了得到方差和协方差的无偏估计。

    • 协方差为正时，说明X和Y是正相关关系；协方差为负时，说明X和Y是负相关关系；协方差为0时，说明X和Y是相互独立。Cov(X,X)就是X的方差。

    • 当样本是n维数据时，它们的协方差实际上是协方差矩阵(对称方阵)。例如，对于3维数据(x,y,z)，计算它的协方差就是：

    对于数据X的散度矩阵为Scatter matrix。其实协方差矩阵和散度矩阵关系密切，散度矩阵就是协方差矩阵乘以（总数据量n-1）。因此它们的特征值和特征向量是一样的。这里值得注意的是，散度矩阵是SVD奇异值分解的一步，因此PCA和SVD是有很大联系。

    1
    2
    3
    4
    5
    6
    7
    A = np.random.randint(0,10,size = (3,3))
    # 协方差
    cov = np.cov(A,rowvar=True)
    # 散度矩阵
    B = (A - A.mean(axis = 1).reshape(-1,1))
    scatter = B.dot(B.T)
    display(A,cov,scatter)

    4.2.特征值分解矩阵原理

    • 特征值与特征向量

      Av=λvAv = \lambda v

      其中，λ是特征向量v对应的特征值，一个矩阵的一组特征向量是一组正交向量

    • 特征值分解矩阵

      对于矩阵A，有一组特征向量v，将这组向量进行正交化单位化，就能得到一组正交单位向量。特征值分解，就是将矩阵A分解为如下式：

      A=P∧P−1A = P \wedge P^{-1}

      矩阵相似对角化

      其中，P是矩阵A的特征向量组成的矩阵，$$\wedge$$则是一个对角阵，对角线上的元素就是特征值。

    4.3.SVD分解矩阵原理

    • 是一种因子分解运算，将一个矩阵分解为3个矩阵的乘积

    • 3个矩阵: U, Σ 和 V，其中U和V是正交矩阵，分别称为左奇异值、右奇异值，Σ 为奇异值

    • 奇异值分解是一个能适用于任意矩阵的一种分解的方法，对于任意矩阵A总是存在一个奇异值分解：

    • ​$$A \approx UΣV^T$$

    • full_matrices=True时，表示U和V是全矩阵

      ​$$A_{m \times n} \approx U_{m \times m}Σ_{n \times n}V_{n \times n}^T$$

      ​假设A是一个$$mn$$的矩阵，那么得到的U是一个$$mm$$的方阵，U里面的正交向量被称为左奇异向量。Σ是一个$$mn$$的矩阵，Σ除了对角线其它元素都为0，对角线上的元素称为奇异值。v的转置矩阵，是一个$$nn$$的矩阵，它里面的正交向量被称为右奇异值向量。而且一般来讲，我们会将Σ上的值按从大到小的顺序排列。

    • full_matrices=False时，表示U和V不是全矩阵

      Am×n≈Um×kΣk×kVk×nTA_{m \times n} \approx U_{m \times k}Σ_{k \times k}V_{k \times n}^T

      ​假设A是一个$$mn$$的矩阵，那么得到的U是一个$$mk$$的方阵，U里面的正交向量被称为左奇异向量。Σ是一个$$kk$$的矩阵，Σ除了对角线其它元素都为0，对角线上的元素称为奇异值。v的转置矩阵，是一个$$ kn$$的矩阵，它里面的正交向量被称为右奇异值向量。而且一般来讲，我们会将Σ上的值按从大到小的顺序排列。

  5. PCA算法两种实现方式：

    5.1.基于特征值分解协方差矩阵实现PCA算法:

    • 去平均值(即去中心化)，即每一位特征减去各自的平均值
    • 计算协方差矩阵
    • 用特征值分解方法求协方差矩阵的特征值与特征向量
    • 对特征值从大到小排序，选择其中最大的k个。然后将其对应的k个特征向量分别作为行向量组成特征向量矩阵ev
    • 将数据转换到k个特征向量构建的新空间中，即X_pca= X⋅evX \cdot ev
    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
    # 1、去中心化
    B = X - X.mean(axis = 0)
    B[:5]

    # 2、协方差
    # 方差是协方差特殊形式
    # 协方差矩阵
    V = np.cov(B,rowvar=False,bias = True)

    # 3、协方差矩阵的特征值和特征向量
    # 特征值和特征向量矩阵的概念
    eigen,ev = np.linalg.eig(V)
    display(eigen,ev)

    # 4、降维标准，2个特征，选取两个最大的特征值所对应的特征的特征向量
    #  百分比，计算各特征值，占权重，累加可以
    cond = (eigen/eigen.sum()).cumsum() >= 0.98
    index = cond.argmax()
    ev = ev[:,:index + 1]

    # 5、进行矩阵运算
    pca_result = B.dot(ev)

    # 6、标准化
    pca_result = (pca_result -pca_result.mean(axis = 0))/pca_result.std(axis = 0)
    pca_result[:5]

    5.2.基于SVD分解协方差矩阵实现PCA算法

    • 去平均值(即去中心化)，即每一位特征减去各自的平均值
    • 通过SVD对第一步结果进行奇异值分解
    • 特征值默认从大到小排列，选择k个作为降维特征，对左奇异值矩阵进行切片即可（U[:,:k]）
    • 归一化处理（无偏差、偏差）
    • 无偏估计
    • S=1n∑i=1n(xi−μ)2S = \sqrt{\frac{1}{n}\sum\limits_{i = 1}^n(x_i - \mu)^2} 总体标准差
    • S=1n−1∑i=1n(xi−X‾)2S = \sqrt{\frac{1}{n-1}\sum\limits_{i = 1}^n(x_i - \overline{X})^2} 样本标准差
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    from scipy import linalg
    n_components_ = 3
    X,y = datasets.load_iris(return_X_y = True)

    # 1、去中心化
    mean_ = np.mean(X, axis=0)
    X -= mean_

    # 2、奇异值分解
    U, S, Vt = linalg.svd(X, full_matrices=False)

    # 3、符号翻转（如果为负数，那么变成正直）
    max_abs_cols = np.argmax(np.abs(U), axis=0)
    signs = np.sign(U[max_abs_cols, range(U.shape[1])])
    U *= signs

    # 4、降维特征筛选
    U = U[:, :n_components_]

    # 5、归一化
    # U = (U - U.mean(axis = 0))/U.std(axis = 0)
    U *= np.sqrt(X.shape[0] - 1)
    U[:5]

  6. PCA降维手写数字，支持向量机SVC进行训练和预测

    7.1.PCA降维手写数字数据，保留95%的重要特征

    7.2.使用降维数据和原始数据分别进行训练和预测

    7.3.对比算法学习降维数据和原始数据准确率与运行时间

LDA线性判别

  1. LDA线性判别分析也是一种经典的降维方法，LDA是一种监督学习的降维技术，也就是说它的数据集的每个样本是有类别输出的。这点和PCA不同。PCA是不考虑样本类别输出的无监督降维技术。LDA的思想可以用一句话概括，就是“投影后类内方差最小，类间方差最大”。什么意思呢？ 我们要将数据在低维度上进行投影，投影后希望每一种类别数据的投影点尽可能的接近，而不同类别的数据的类别中心之间的距离尽可能的大。
    可能还是有点抽象，我们先看看最简单的情况。假设我们有两类数据分别为红色和蓝色，如下图所示，这些数据特征是二维的，我们希望将这些数据投影到一维的一条直线，让每一种类别数据的投影点尽可能的接近，而红色和蓝色数据中心之间的距离尽可能的大。

  2. 给定训练集样例，设法将样例投影到一条直线上，使得同类样例的投影尽可能接近，异类样例的投影点尽可能原理；在对新的样本进行分类时，将其投影到同样的这条直线上，再根据投影点的位置来确定新样本的类别

  3. LDA算法实现方式

    • 计算数据总的散度矩阵$$S_t$$
    • 计算数据类内散度矩阵$$S_w$$
    • 计算类间散度矩阵$$S_b$$
    • 特征值和特征向量计算
    • 筛选特征向量，进行矩阵运算返回输出结果
    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
    import numpy as np
    from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
    from sklearn import datasets
    # scipy这个模块下的线性代数子模块
    from scipy import linalg

    # 加载数据
    X,y = datasets.load_iris(return_X_y=True)
    X[:5]

    # 1、总的散度矩阵
    # 协方差
    St = np.cov(X.T,bias = 1)
    St

    # 2、类内的散度矩阵
    # Scatter散点图，within（内）
    Sw = np.full(shape = (4,4),fill_value=0,dtype=np.float64)
    for i in range(3):
        Sw += np.cov(X[y == i],rowvar = False,bias = 1)
    Sw/=3
    Sw

    # 3、计算类间的散度矩阵
    # Scatter  between 
    Sb = St - Sw
    Sb

    # 4、特征值，和特征向量
    eigen,ev = linalg.eigh(Sb,Sw)
    ev = ev[:, np.argsort(eigen)[::-1]][:,:2]
    ev

    # 5、删选特征向量，进行矩阵运算
    X.dot(ev)[:5]

NMF非负矩阵分解

  1. NMF的基本思想可以简单描述为：对于任意给定的一个非负矩阵A，NMF算法能够寻找到一个非负矩阵U和一个非负矩阵V，使得满足 ，从而将一个非负的矩阵分解为左右两个非负矩阵的乘积。

  2. 解前后可理解为：原始矩阵V的列向量是对左矩阵W中所有列向量的加权和，而权重系数就是右矩阵对应列向量的元素，故称W为基矩阵，H为系数矩阵。一般情况下$$k$$(W矩阵的列数）的选择要比N小，满足$$(F+N)k < FN$$，这时用系数矩阵W代替原始矩阵，就可以实现对原始矩阵进行降维，得到数据特征的降维矩阵，从而减少存储空间，减少计算机资源。

  3. 原矩阵V中的一列向量可以解释为对左矩阵W中所有列向量(称为基向量)的加权和，而权重系数为右矩阵H中对应列向量中的元素。这种基于基向量组合的表示形式具有很直观的语义解释，它反映了人类思维中“局部构成整体”的概念。

  4. 虽然NMF是一个很厉害的算法，但其实质是加权和，我们可以在原理上等效为基本的线性方程：

    y=a1x1+a2x2+……+anxny = a_1x_1 + a_2x_2 +……+ a_nx_n

    y$$构成了原矩阵中的元素，$$a$$是权重，$$x$$是特征。矩阵乘法中特征用列向量表示，权重系数用行向量表示，所以成了图中所看到的样子。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    import numpy as np
    from sklearn import datasets
    from sklearn.decomposition import NMF

    # 加载数据
    X,y = datasets.load_iris(return_X_y=True)

    # 声明算法
    nmf = NMF(n_components=2,init = 'nndsvda',max_iter=1000)

    # 降维之后的数据
    W = nmf.fit_transform(X)
    display(W[:5])

    # NMF另一半矩阵H
    H = nmf.components_

    # X ≈ W • H

LLE局部线性嵌入降维算法

  1. 所谓LLE（局部线性嵌入）即”Locally Linear Embedding”的降维算法，在处理所谓流形降维的时候，效果比PCA要好很多。首先，所谓流形，我们脑海里最直观的印象就是Swiss roll,在吃它的时候喜欢把它整个摊开成一张饼再吃，其实这个过程就实现了对瑞士卷的降维操作，即从三维降到了两维。降维前，我们看到相邻的卷层之间看着距离很近，但其实摊开成饼状后才发现其实距离很远，所以如果不进行降维操作，而是直接根据近邻原则去判断相似性其实是不准确的。

  2. 和传统的PCA，LDA等关注样本方差的降维方法相比，LLE关注于降维时保持样本局部的线性特征（保持原有拓扑结构），由于LLE在降维时保持了样本的局部特征，它广泛的用于图像识别，高维数据可视化等领域。LLE是非线性降维技术，可以说是流形学习方法最经典的算法之一。很多后续的流形学习、降维方法都与LLE有密切联系。

3.传统的机器学习方法中，数据点和数据点之间的距离和映射函数都是定义在欧式空间中的，然而在实际情况中，这些数据点可能不是分布在欧式空间中的（比如黎曼空间），因此传统欧式空间的度量难以用于真实世界的非线性数据，从而需要对数据的分布引入新的假设。黎曼空间就是弯曲的空间

4.LLE的降维实现过程，直观的可视化效果如下图所示

5.LLE算法认为每一个数据点都可以由其近邻点的线性加权组合构造得到，LLE算法主要步骤：

  • 寻找每个样本点的k个近邻点；
  • 由每个样本点的近邻点计算出该样本点的局部重建权值矩阵；
  • 由该样本点的局部重建权值矩阵和其近邻点计算出该样本点的输出值。

6.LLE算法示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 降维，高维数据降成低维的数据
# manifold 流形
from sklearn.manifold import LocallyLinearEmbedding
from sklearn.decomposition import PCA
from sklearn import datasets
import matplotlib.pyplot as plt
%matplotlib inline
from mpl_toolkits.mplot3d.axes3d import Axes3D
X,t = datasets.make_swiss_roll(n_samples=1500,noise=0.05,random_state= 1024)
fig = plt.figure(figsize=(12,9))
# axes3D = Axes3D(fig)
axes3D = fig.add_subplot(projection = '3d')
axes3D.view_init(7,-80)
axes3D.scatter(X[:,0],X[:,1],X[:,2],c = t)
1
2
3
pca = PCA(n_components= 2)
X_pca = pca.fit_transform(X)
plt.scatter(X_pca[:,0],X_pca[:,1],c = t)
1
2
3
4
lle = LocallyLinearEmbedding(n_neighbors=10,n_components=2)
lle.fit(X)
X_lle = lle.transform(X)
plt.scatter(X_lle[:,0],X_lle[:,1],c = t)
]]> <p>[TOC]</p> <h3 id="相关背景">相关背景</h3> <ul> <li>在许多领域的研究与应用中，通常需要对含有多个变量的数据进行观测，收集大量数据后进行分析研究寻找规律。<font color=red><strong>多变量大数据集</strong></fo images http://git.molittle.site/posts/e01fbe6a.html 2025-06-10T03:45:55.000Z 2025-06-10T05:26:35.844Z 1-聚类

]]> <p><img src="./images/1-%E8%81%9A%E7%B1%BB.png" alt="1-聚类"></p> SVC支持向量机综合案例 http://git.molittle.site/posts/f219e09d.html 2025-06-09T02:45:44.000Z 2025-07-25T14:42:42.074Z 1、支持向量机原理可视化

1.1、导包

1
2
3
4
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from sklearn.svm import SVC

1.2、创建数据

1
2
3
4
5
rs = np.random.RandomState(256)
X = rs.randn(300,2)
y = X[:,0]*X[:,1] >=0
plt.figure(figsize=(6,6))
plt.scatter(X[:,0],X[:,1])

1.3、创建测试数据

1
2
3
4
5
6
7
x1 = np.linspace(-3,3,20)
x2 = np.linspace(-3,3,18)
X1,X2 = np.meshgrid(x1,x2)
plt.figure(figsize=(6,6))
plt.scatter(X1,X2)
X_test = np.concatenate([X1.reshape(-1,1),X2.reshape(-1,1)],axis = 1)
X_test.shape

1.4、模型训练

1
2
3
4
5
svc = SVC(kernel = 'rbf')
svc.fit(X,y)
y_ = svc.predict(X_test)
plt.figure(figsize=(6,6))
plt.scatter(X_test[:,0],X_test[:,1],c = y_)

1.5、原理2D可视化

1
2
3
4
5
6
7
# 二维 --------> 三维
# 分离平面，上面一类点，下面也是一类点
# 这些点有的距离近，有的距离远
d = svc.decision_function(X_test)
# 等高面
plt.figure(figsize=(5,5))
plt.contourf(X1,X2,d.reshape(180,200))

1.6、原理3D可视化

1
2
3
4
plt.figure(figsize=(12,9))
ax = plt.subplot(111,projection = '3d')
ax.contourf(X1,X2,d.reshape(180,200))
ax.view_init(40,-60)

2、SVC建模人脸识别

2.1、导包

1
2
3
4
5
6
7
import numpy as np
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.model_selection import GridSearchCV
from sklearn import datasets

2.2、数据加载

1
2
3
4
5
6
7
# 第一次加载，需要联网下载
# 下载路径：C:\Users\likai\scikit_learn_data\lfw_home
faces = datasets.fetch_lfw_people(resize= 1,min_faces_per_person=70)
# 形状是：(125,94)
X  = faces['data']
y = faces['target']
display(X.shape,y.shape)

2.3、数据降维与拆分

1
2
3
4
5
6
7
pca = PCA(n_components=0.9)
X_pca = pca.fit_transform(X)
display(X_pca.shape)
X_train,X_test,X_train_pca,X_test_pca,y_train,y_test = train_test_split(X,X_pca,y,test_size = 0.1)

display(X_train.shape,X_test.shape)
display(X_train_pca.shape,X_test_pca.shape)

2.4、直接使用SVC建模预测

1
2
3
4
svc = SVC()
svc.fit(X_train_pca,y_train)
svc.score(X_test_pca,y_test)
# 输出：0.7984496124031008

2.5、网格搜索确定最佳参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
%%time
svc = SVC()
params = {'C':np.logspace(-3,1,20),'kernel':['rbf','poly','sigmoid','linear']}
gc = GridSearchCV(estimator = svc,param_grid = params)
gc.fit(X_train_pca,y_train)
print('网格搜索确定最佳参数：',gc.best_params_)
print('模型得分是：',gc.score(X_test_pca,y_test))
y_pred = gc.predict(X_test_pca)
# 输出
'''
网格搜索确定最佳参数： {'C': 3.792690190732246, 'kernel': 'rbf'}
模型得分是： 0.8837209302325582
Wall time: 36.2 s
'''

2.6、数据可视化

1
2
3
4
5
6
7
8
9
10
target_names = faces.target_names
print('目标任务名字如下：',target_names)
plt.figure(figsize=(5*2,10*3))
for i in range(50):
    plt.subplot(10,5,i + 1)
    plt.imshow(X_test[i].reshape(125,-1),cmap = 'gray')
    true_name = target_names[y_test[i]].split(' ')[-1]
    pred_name = target_names[y_pred[i]].split(' ')[-1]
    plt.title('True:%s\nPred:%s' % (true_name,pred_name))
    plt.axis('off')
]]> <h3 id="1、支持向量机原理可视化">1、支持向量机原理可视化</h3> <h4 id="1-1、导包">1.1、导包</h4> <figure class="highlight python"><table><tr><td class="gutter"><pre><spa 杂谈笔记 http://git.molittle.site/posts/104fd864.html 2025-04-26T14:47:00.000Z 2025-06-10T12:38:41.706Z 之前一些函数名笔记

一些matlab函数名；

可能python也适合用

矩阵运算操作求矩阵的转置 (A)'；
求矩阵的逆 inv(A)；
求矩阵的模det(A)；
2.数运算操作e的次方 exp(A)指数函数；
exp(x) 以e为底数 ；对数函数 log(x) 自然对数，即以e为底数的对数；
log10(x) 常用对数，即以10为底数的对数； log2(x) 以2为底数的x的对数；
开方函数 sqrt(x) 表示x的算术平方根； 绝对值函数 abs(x) 表示实数的绝对值以及复数的模；
三角函数（自变量的单位为弧度）
sin(x) 正弦函数 ；cos(x) 余弦函数； tan(x) 正切函数 ；cot(x) 余切函数 ；sec(x) 正割函数 ；csc(x) 余割函数；
反三角函数 asin(x) 反正弦函数； acos(x) 反余弦函数 ；atan(x) 反正切函数 ；acot(x) 反余切函数 ；asec(x) 反正割函数； acsc(x) 反余割函数；
双曲函数 sinh(x) 双曲正弦函数； cosh(x) 双曲余弦函数； tanh(x) 双曲正切函数； coth(x) 双曲余切函数； sech(x) 双曲正割函数 ；csch(x) 双曲余割函数； 反双曲函数 asinh(x) 反双曲正弦函数； acosh(x) 反双曲余弦函数； atanh(x) 反双曲正切函数； acoth(x) 反双曲余切函数 ；asech(x) 反双曲正割函数； acsch(x) 反双曲余割函数 ；
求角度函数 atan2(y,x) 以坐标原点为顶点，x轴正半轴为始边，从原点到点（x，y）的射线为终边的角，其单位为弧度；
数论函数 gcd(a,b) 两个整数的最大公约数 ；lcm(a,b) 两个整数的最小公倍数 ；
排列组合函数 factorial(n) 阶乘函数，表示n的阶乘；
复数函数 real(z) 实部函数；imag(z) 虚部函数 ；abs(z) 求复数z的模； angle(z) 求复数z的辐角；conj(z) 求复数z的共轭复数 ；
求整函数与截尾函数 ceil(x) 表示大于或等于实数x的最小整数 ；
floor(x) 表示小于或等于实数x的最大整数；
round(x) 最接近x的整数；
最大、最小函数 max([a，b，c，．．．])
求最大数 ；min([a，b，c，．．])
求最小数 ；符号函数 sign(x)

一些简短的算法笔记

n第k位数字：n>>k&1
返回n的最后一位1：lowbit(n) = n & -n
C++的nth_element函数，cin.tie(0)或者ios::sync_with_stdio(false);

KMP扩展：BM算法;Sunday算法。

并查集按秩合并
Arrays.fill(arr,-1);C++memset();memcopy
c++reference
Character.isDigit(‘c’)—false
需要注意的是 在windows中按一下回车键 一共有两个字符 “\n\r” 而read()只能读取一个字符，所以如要要用read来达到吸收回车的目的，需要用两个read(); 如果用readLine()的话会将"\n\r"全部吸收 ， 所以只需要一个readLine()来吸收回车.
readLine()用回车来进行下一步操作//cin.sval;只适合吸收非数字字符，不吸收空格。
int num2 = Integer.parseInt(str);
String ss = String.valueOf(n);
数字字符串用BufferedReader

//字符串转化字符数组过程中从下表零开始
并查集按秩合并

cin.nextToken();String st=cin.sval;str=st.toCharArray();int res = Integer.MAX_VALUE;g[i][j] = Integer.parseInt(String.valueOf(s.charAt(j)));in.readLine();g[i][j] = s.charAt(j) - '0';浮点数//double a;//String str=String.format("%.2f",a)//!!!!!!!//cout.print(str);//或者 cout,printf("%.6f",a);//检查Segm fault错误System.exit(0);//全新输入 String []str=in.readLine().split(" ");n=Integer.parseInt(str[0]);m=Integer.parseInt(str[1])
]]> <h2 id="之前一些函数名笔记">之前一些函数名笔记</h2> <p><em>一些matlab函数名；</em></p> <p><em>可能python也适合用</em></p> <p><strong>矩阵运算操作求矩阵的转置 (A)'；</strong><br> <stro Hello World http://git.molittle.site/posts/4a17b156.html 2025-04-24T04:00:58.445Z 2025-07-25T14:37:45.883Z Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment

]]> <p>Welcome to <a href="https://hexo.io/">Hexo</a>! This is your very first post. Check <a href="https://hexo.io/docs/">documentation</a> for math http://git.molittle.site/posts/a927044d.html 2025-04-11T14:34:49.000Z 2025-07-25T14:38:35.129Z 求100!的约数个数和约数之和
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
51
52
53
54
55
56
package lanqiao;
import java.util.*;
public class math0 {
    static List<Integer>primes=new LinkedList<Integer>();
    static void sPrime(int n) {
        boolean[]st=new boolean[n+1];
        for(int i=2;i<=n;i++) {
            if(!st[i])primes.add(i);
            for(int j=0;primes.get(j)*i<=n;j++) {
                st[primes.get(j)*i]=true;
                if(i%primes.get(j)==0)break;
            }
        }
    }
    static int minc(int n,int p) {
        int rxp=0;
        while(n>0) {
            n/=p;
            rxp+=n;
        }
        return rxp;
    }
    static long qui(long a,long b) {
        long res=1;
        while(b>0) {
            if((b&1)==1) {
                res*=a;
            }
            a=a*a;
            b/=2;
        }
        return res;
    }
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int n=100;
        sPrime(n);
        int []exp=new int[primes.size()];
        for(int i=0;i<primes.size();i++) {
            int p=primes.get(i);
            exp[i]=minc(n,p);
        }
        int numy=1;
        for(int e:exp) {
            numy*=(e+1);
        }
        long sumy=1L;
        for(int i=0;i<primes.size();i++) {
            int p=primes.get(i);
            int e=exp[i];
            sumy*=(qui(p,e+1)-1)/(p-1);
        }
        System.out.println(numy+"  "+sumy);
        scan.close();
    }
}

质因数分解

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
import java.util.HashMap;
import java.util.Map;

public class PrimeFactorization {
    public static void main(String[] args) {
        int x = 100; // 待分解的数
        Map<Integer, Integer> primeFactors = divide(x);

        // 输出质因数及其次数
        for (Map.Entry<Integer, Integer> entry : primeFactors.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }

    public static Map<Integer, Integer> divide(int x) {
        Map<Integer, Integer> primeFactors = new HashMap<>();

        for (int i = 2; i <= x / i; i++) {
            if (x % i == 0) {
                int count = 0;
                while (x % i == 0) {
                    x /= i;
                    count++;
                }
                primeFactors.put(i, count);
            }
        }

        // 如果最后剩下的x > 1，说明它本身是质数
        if (x > 1) {
            primeFactors.put(x, 1);
        }

        return primeFactors;
    }
}

欧拉函数（Euler’s Totient Function）

欧拉函数 ϕ(n)ϕ(n) 表示小于或等于 n_n_ 的正整数中与 n_n_ 互质的数的个数。 性质：

  • 若 n_是质数，ϕ(n)=n−1_ϕ(n)=_n_−1。
  • 若 n=pk_n_=*pk_，ϕ(n)=pk−pk−1_ϕ_(n)=_pk_−_p*_k_−1。
  • 若 n=a×b_n_=a_×_b 且 a_a_ 和 b_b_ 互质，ϕ(n)=ϕ(a)×ϕ(b)ϕ(n)=ϕ(a)×_ϕ_(b)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class EulerTotient {
    public static int eulerTotient(int n) {
        int result = n;
        for (int p = 2; p * p <= n; p++) {
            if (n % p == 0) {
                while (n % p == 0) {
                    n /= p;
                }
                result -= result / p;
            }
        }
        if (n > 1) {
            result -= result / n;
        }
        return result;
    }

    public static void main(String[] args) {
        int n = 10;
        System.out.println("欧拉函数φ(" + n + ") = " + eulerTotient(n));
    }
}

别考，求！

卢卡斯定理（Lucas Theorem）及其适用性

卢卡斯定理的表述

若 p_p_ 是质数，则对于任意整数 1≤m≤n1≤_m_≤_n_，组合数 C(n,m)C(n,m) 满足：

C(n,m)≡C(n mod p,m mod p)×C(⌊np⌋,⌊mp⌋)(modp)C(n,m)≡_C_(n_mod_p,m_mod_p)×_C_(⌊*pn_⌋,⌊_pm_⌋)(mod_p*)

其中：

  • C(n mod p,m mod p)C(n_mod_p,m_mod_p) 是 小规模组合数（直接用公式计算）。
  • C(⌊np⌋,⌊mp⌋)C(⌊*pn_⌋,⌊_pm*⌋) 是 递归计算的组合数。

适用条件

  1. p*p* 必须是质数，否则卢卡斯定理不成立。
  2. 适用于 n*n* 和 m*m* 较大的情况（如 n,m≤1018_n_,m_≤1018，但 p_p 较小）。
  3. 不适用于非质数模数（如 p=4_p_=4 或 p=109+7_p_=109+7 但非质数）。
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
若p是质数，则对于任意整数 1 <= m <= n，有：
    C(n, m) = C(n % p, m % p) * C(n / p, m / p) (mod p)

int qmi(int a, int k, int p)  // 快速幂模板
{
    int res = 1 % p;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}

int C(int a, int b, int p)  // 通过定理求组合数C(a, b)
{
    if (a < b) return 0;

    LL x = 1, y = 1;  // x是分子，y是分母
    for (int i = a, j = 1; j <= b; i --, j ++ )
    {
        x = (LL)x * i % p;
        y = (LL) y * j % p;
    }

    return x * (LL)qmi(y, p - 2, p) % p;
}

int lucas(LL a, LL b, int p)
{
    if (a < p && b < p) return C(a, b, p);
    return (LL)C(a % p, b % p, p) * lucas(a / p, b / p, p) % p;
}

扩展卢卡斯定理（Lucas Theorem）

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ExLucas {

    // 质因数分解 p = p1^k1 * p2^k2 * ... * pm^km
    public static Map<Integer, Integer> factorize(int p) {
        Map<Integer, Integer> factors = new HashMap<>();
        for (int i = 2; i * i <= p; i++) {
            while (p % i == 0) {
                factors.put(i, factors.getOrDefault(i, 0) + 1);
                p /= i;
            }
        }
        if (p > 1) factors.put(p, 1);
        return factors;
    }

    // 计算 n! 中去除 p 的因子后的值 mod p^k
    public static int factorialMod(int n, int p, int pk) {
        if (n == 0) return 1;
        int res = 1;
        for (int i = 1; i <= pk; i++) {
            if (i % p == 0) continue; // 跳过 p 的倍数
            res = (res * i) % pk;
        }
        res = powMod(res, n / pk, pk);
        for (int i = 1; i <= n % pk; i++) {
            if (i % p == 0) continue;
            res = (res * i) % pk;
        }
        return (res * factorialMod(n / p, p, pk)) % pk;
    }

    // 快速幂算法
    public static int powMod(int base, int exp, int mod) {
        int result = 1;
        base = base % mod;
        while (exp > 0) {
            if (exp % 2 == 1) {
                result = (result * base) % mod;
            }
            exp = exp >> 1;
            base = (base * base) % mod;
        }
        return result;
    }

    // 计算 n! 中 p 的幂次
    public static int countP(int n, int p) {
        int count = 0;
        while (n > 0) {
            n /= p;
            count += n;
        }
        return count;
    }

    // 计算 C(n, m) mod p^k
    public static int combModPk(int n, int m, int p, int pk) {
        if (m > n) return 0;
        int num = factorialMod(n, p, pk);
        int den1 = factorialMod(m, p, pk);
        int den2 = factorialMod(n - m, p, pk);
        int den = (den1 * den2) % pk;
        int invDen = modInverse(den, pk); // 逆元
        int powP = countP(n, p) - countP(m, p) - countP(n - m, p);
        return (num * invDen % pk * powMod(p, powP, pk)) % pk;
    }

    // 计算模逆元
    public static int modInverse(int a, int m) {
        return powMod(a, m - 2, m);
    }

    // 中国剩余定理（CRT）合并同余方程
    public static int crt(List<Integer> remainders, List<Integer> mods) {
        int M = 1;
        for (int mod : mods) {
            M *= mod;
        }
        int res = 0;
        for (int i = 0; i < remainders.size(); i++) {
            int mi = mods.get(i);
            int Mi = M / mi;
            int invMi = modInverse(Mi, mi);
            res = (res + remainders.get(i) * Mi % M * invMi % M) % M;
        }
        return res;
    }

    // 扩展卢卡斯定理：计算 C(n, m) mod p（p 非质数）
    public static int exLucas(int n, int m, int p) {
        Map<Integer, Integer> factors = factorize(p);
        List<Integer> remainders = new ArrayList<>();
        List<Integer> mods = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : factors.entrySet()) {
            int prime = entry.getKey();
            int exp = entry.getValue();
            int pk = (int) Math.pow(prime, exp);
            int rem = combModPk(n, m, prime, pk);
            remainders.add(rem);
            mods.add(pk);
        }
        return crt(remainders, mods);
    }

    public static void main(String[] args) {
        int n = 100;
        int m = 50;
        int p = 12; // 非质数模数
        int result = exLucas(n, m, p);
        System.out.println("C(" + n + ", " + m + ") mod " + p + " = " + result);
    }
}

并查集

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
51
52
53
54
55
56
57
import java.util.*;
public class Main{
  static int[]father;
  static long[]value;
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int M=scan.nextInt();
    int Q=scan.nextInt();
    father=new int[N+1];
    value=new long[N+1];
    init(N);
    for(int i=0;i<M;i++){
      int left=scan.nextInt();
      int right=scan.nextInt();
      long s=scan.nextLong();
      left--;
      union(left,right,s);
    }
    for(int i=0;i<Q;i++){
      int l=scan.nextInt();
      int r=scan.nextInt();
      l--;
      int lFa=find(l);
      int rFa=find(r);
      if(lFa==rFa){
        System.out.println(value[l]-value[r]);
      }else{
        System.out.println("UNKNOWN");
      }
    }
    scan.close();
  }
  static void init(int N){
    for(int i=0;i<=N;i++){
      father[i]=i;
    }
  }
  static int find(int x){
    if(x!=father[x]){
      int tmp=father[x];
      father[x]=find(father[x]);
      value[x]+=value[tmp];
    }
    return father[x];
  }
  static void union(int left,int right,long s){
    int lF=find(left);
    int rF=find(right);
    if(lF!=rF){
      int min=Math.min(lF,rF);
      int max=Math.max(lF,rF);
      father[min]=max;
      value[min]=Math.abs(value[right]-value[left]+s);
    }
  }
}
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
import java.util.*;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
  static int N=110;
  static int n,Q;
  static long[][]cnt;
  static long[][]ans;
  static long[][]lns;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        n=scan.nextInt();
        Q=scan.nextInt();
        cnt=new long[N][N];
        ans=new long[N][N];
        lns=new long[N][N];
        for(int i=1;i<=n;i++){
          for(int j=1;j<=n;j++){
            ans[i][j]=scan.nextLong();
          }
        }
        for(int i=1;i<=n;i++){
          for(int j=1;j<=n;j++){
            lns[i][j]=scan.nextInt();
            cnt[i][j]=lns[i][j];
          }
        }
        if(floyd()>Q){
          System.out.println(-1);
          return;
        }
        long l=0,r=10000010;
        while(l<r){
          long mid=l+r>>1;
          if(check(mid))r=mid;//minhua
          else l=mid+1;
        }
        System.out.println(r);
        scan.close();
    }
    static long floyd(){
      //最短路下线
      long a=0;
      for(int k=1;k<=n;k++){
          for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
              cnt[i][j]=Math.min(cnt[i][j],cnt[i][k]+cnt[k][j]);
            }
          }
        }
        for(int i=1;i<=n;i++){
          for(int j=1;j<=n;j++){
            a+=cnt[i][j];
          }
        }
        return a;
    }
    static boolean check(long x){
      for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
          cnt[i][j]=ans[i][j];
        }
      }
      long h=x/n;
      long s=x%n;
      for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
          if(i==j)continue;
          if(i<=s)cnt[i][j]=Math.max(lns[i][j],cnt[i][j]-1-h);
          else cnt[i][j]=Math.max(lns[i][j],cnt[i][j]-h);
          cnt[j][i]=cnt[i][j];
        }
      }
      return floyd()<=Q;
    }
}

dij

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package lanqiao;
import java.util.*;
public class dj {
    static int m,n;
    static long[][]dis;
    static boolean[][]st;
    static ArrayList<long[]>[][]list;
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        n=scan.nextInt();
        m=scan.nextInt();
        dis=new long[n+1][m+1];
        st=new boolean[n+1][m+1];
        int[][]a=new int[n+1][m+1];
        list=new ArrayList[n+1][m+1];
        for(int i=1;i<=n;i++) {
            for(int j=1;j<=m;j++) {
                list[i][j]=new ArrayList<long[]>();
                a[i][j]=scan.nextInt();
            }
        }
        for(int i=1;i<=n;i++) {
            for(int j=1;j<=m;j++) {
            if(i>1)list[i][j].add(new long[] {i-1,j,a[i-1][j]});
            if(j>1)list[i][j].add(new long[] {i,j-1,a[i][j-1]});
            if(i<n)list[i][j].add(new long[] {i+1,j,a[i+1][j]});
            if(j<m)list[i][j].add(new long[] {i,j+1,a[i][j+1]});
            }
        }
        dij(a[1][1]);
        long max=0;
        for(int i=1;i<=n;i++) {
            for(int j=1;j<=m;j++) {
                max=Math.max(dis[i][j],max);
            }
        }
        System.out.println(max);
        scan.close();
    }
    static void dij(int start) {
        for(int i=1;i<=n;i++) {
            Arrays.fill(dis[i],Long.MAX_VALUE);
        }

        PriorityQueue<long[]>p=new PriorityQueue<long[]>(Comparator.comparing(k->k[2]));
        dis[1][1]=start;
        p.add(new long[]{1,1,start});
        while(!p.isEmpty()) {
            long[]t=p.poll();
            int x=(int)t[0];
            int y=(int)t[1];
            if(st[x][y])continue;
            st[x][y]=true;
            for(long[]a:list[x][y]) {
                int x1=(int)a[0];
                int y1=(int)a[1];
                long w=a[2];
                if(dis[x1][y1]>dis[x][y]+w) {
                    dis[x1][y1]=dis[x][y]+w;
                    p.add(new long[] {x1,y1,dis[x1][y1]});
                }
            }
        }

    }

}

dfs

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
import java.util.*;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
  static int N=110;
  static int n,Q;
  static long[][]cnt;
  static long[][]ans;
  static long[][]lns;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        n=scan.nextInt();
        Q=scan.nextInt();
        cnt=new long[N][N];
        ans=new long[N][N];
        lns=new long[N][N];
        for(int i=1;i<=n;i++){
          for(int j=1;j<=n;j++){
            ans[i][j]=scan.nextLong();
          }
        }
        for(int i=1;i<=n;i++){
          for(int j=1;j<=n;j++){
            lns[i][j]=scan.nextInt();
            cnt[i][j]=lns[i][j];
          }
        }
        if(floyd()>Q){
          System.out.println(-1);
          return;
        }
        long l=0,r=10000010;
        while(l<r){
          long mid=l+r>>1;
          if(check(mid))r=mid;//minhua
          else l=mid+1;
        }
        System.out.println(r);
        scan.close();
    }
    static long floyd(){
      //最短路下线
      long a=0;
      for(int k=1;k<=n;k++){
          for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
              cnt[i][j]=Math.min(cnt[i][j],cnt[i][k]+cnt[k][j]);
            }
          }
        }
        for(int i=1;i<=n;i++){
          for(int j=1;j<=n;j++){
            a+=cnt[i][j];
          }
        }
        return a;
    }
    static boolean check(long x){
      for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
          cnt[i][j]=ans[i][j];
        }
      }
      long h=x/n;
      long s=x%n;
      for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
          if(i==j)continue;
          if(i<=s)cnt[i][j]=Math.max(lns[i][j],cnt[i][j]-1-h);
          else cnt[i][j]=Math.max(lns[i][j],cnt[i][j]-h);
          cnt[j][i]=cnt[i][j];
        }
      }
      return floyd()<=Q;
    }
}
]]> <h3 id="求100-的约数个数和约数之和">求100!的约数个数和约数之和</h3> <figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</s 二分 http://git.molittle.site/posts/9947c71c.html 2025-04-09T15:39:18.000Z 2025-06-10T12:38:41.688Z 最小值最大化
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
import java.util.*;
public class Main{
    static int N=100010;
    static int[]h=new int[N];
    static int[]w=new int[N];
    static int n,k;
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        n=scan.nextInt();
        k=scan.nextInt();
        h=new int[n];
        w=new int[n];
        for(int i=0;i<n;i++) {
            h[i]=scan.nextInt();
            w[i]=scan.nextInt();
        }
        int l=1,r=(int)1e5+10;
        while(l<r) {
            int mid=(r+l+1)/2;
            if(check(mid))l=mid;
            else r=mid-1;
        }
        System.out.println(l);
}
    static boolean check(int x) {
        long res=0;
        for(int i=0;i<n;i++) {
        res+=(h[i]/x)*(w[i]/x);
        }
        if(res>=k) {
            return true;
        }
        return false;
    }
}

最大值最小化

题目：共n个月,给出每个月的开销.将n个月划分成m个时间段,求m个时间段中开销最大的时间段的最小开销值。
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
#include<bits/stdc++.h>
using namespace std;
int n,m;
vector<int>a;
int check(int M){
    int ct=0,now=0;
    for(int i=0;i<n;i++){
        if(a[i]>M) return 0;
        if(now+a[i]>M){
            ct++;
            now=0;    
        }    
        now+=a[i];
    }
    return ct<m;
}
int main(){
    cin>>n>>m;
    a.resize(n);
    int R=0,L=0;
    for(int i=0;i<n;i++){
        cin>>a[i];
        R+=a[i];
        L=max(L,a[i]);
    }
    R++;    
    while(L<R){
        int M=(L+R)/2;
        if(check(M)) R=M;
        else L=M+1;
    }
    cout<<L<<endl;
    return 0;
}
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
//更安全的求最大值最小化
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static  int N=100010,n,k,t;
    static  long a[]=new long[N];
    public  static  boolean check(int m){
        long arr[]=new long[m+5];
        long s[]=new long[m+5];
        long s_pow[]=new long[m+5];
        for(int i=1;i<=m;i++) arr[i]=a[i];
        Arrays.sort(arr,1,m+1);
        for(int i=1;i<=m;i++){
            s[i]=s[i-1]+arr[i];
            s_pow[i]=s_pow[i-1]+(arr[i]*arr[i]);
        }
        for(int i=k;i<=m;i++){
            long s1=s_pow[i]-s_pow[i-k];
            long s2=s[i]-s[i-k];
            double avg=s2*1.00/k;
//把他给的方差公式 可以优化 成这个 提醒平方差公式
            double res=(s1-2*avg*s2+k*avg*avg)/k;
            if(res<t) return  true;
        }
        return  false;
    }
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        k=sc.nextInt();
        t=sc.nextInt();
        for(int i=1;i<=n;i++){
            a[i]=sc.nextLong();
        }
        int l=k,r=n;
        int res=-1;
        while (l<=r){
            int mid=(l+r)>>1;
            if(check(mid)){
                r=mid-1;
                res=mid;
            }else{
                l=mid+1;
            }
        }
        System.out.println(res);
    }
}
]]> <h3 id="最小值最大化">最小值最大化</h3> <figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span clas Floyd http://git.molittle.site/posts/97c8f9ac.html 2025-04-02T15:23:50.000Z 2025-04-25T09:03:31.781Z 星际旅行

问题描述

小明国庆节准备去某星系进行星际旅行，这个星系里一共有 n_n_ 个星球，其中布置了 m_m_ 道双向传送门，第 i_i_ 道传送门可以连接 ai,bi*ai_,_bi 两颗星球（ai≠bi_a**i\=_b**i* 且任意两颗星球之间最多只有一个传送门）。

他看中了一款 “旅游盲盒”，一共有 Q_Q_ 个盲盒，第 i_i_ 个盲盒里的旅行方案规定了旅行的起始星球 xi*xi _和最多可以使用传送门的次数 yi_yi*。只要从起始星球出发，使用传送门不超过规定次数能到达的所有星球都可以去旅行。

小明关心在每个方案中有多少个星球可以旅行到。小明只能在这些盲盒里随机选一个购买，他想知道能旅行到的不同星球的数量的期望是多少。

输入格式

输入共 m+Q+1_m_+Q+1 行。

第一行为三个正整数 n,m,Q_n_,m,Q 。

后面 m_m_ 行，每行两个正整数 ai,bi*ai_,_bi* 。

后面 Q_Q_ 行，每行两个整数 xi,yi*xi_,_yi* 。

输出格式

输出共一行，一个浮点数（四舍五入保留两位小数）。

样例输入

1
2
3
4
5
6
3 2 3
1 2
2 3
2 1
2 0
1 1

样例输出

1
2.00

样例说明

第一个盲盒可以旅行到 1,2,31,2,3。

第二个盲盒可以旅行到 22。

第三个盲盒可以旅行到 1,21,2。

所以期望是 (3+1+2)/3=2.00(3+1+2)/3=2.00。

解决

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
import java.util.*;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
  static int n,m,q;
  static int[][]con;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        q=sc.nextInt();
        con=new int[n+1][n+1];
        for(int i=1;i<=n;i++){
          Arrays.fill(con[i],3010);
        }
        for(int i=1;i<=n;i++){
          con[i][i]=0;
        }
        for(int i=0;i<m;i++){
          int a=sc.nextInt();
          int b=sc.nextInt();
          con[a][b]=1;
          con[b][a]=1;
        }
        for(int k=1;k<=n;k++){
          for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
              con[i][j]=Math.min(con[i][j],con[i][k]+con[k][j]);
            }
          }
        }
        int ans=0;
        for(int i=0;i<q;i++){
          int x=sc.nextInt();
          int y=sc.nextInt();
          int count=0;
          for(int j=1;j<=n;j++){
            if(con[x][j]<=y)count++;
          }
            ans+=count;
        }
          System.out.printf("%.2f",(double)ans/q);
    }
}

牛的旅行

题目链接

牛的旅行

问题描述

农民John的农场里有很多牧区，有的路径连接一些特定的牧区。

一片所有连通的牧区称为一个牧场。

但是就目前而言，你能看到至少有两个牧区不连通。

现在，John想在农场里添加一条路径（注意，恰好一条）。

一个牧场的直径就是牧场中最远的两个牧区的距离（本题中所提到的所有距离指的都是最短的距离）。

考虑如下的两个牧场，每一个牧区都有自己的坐标：

1.png

图 1 是有 5 个牧区的牧场，牧区用“*”表示，路径用直线表示。

图 1 所示的牧场的直径大约是 12.07106, 最远的两个牧区是 A 和 E，它们之间的最短路径是 A-B-E。

图 2 是另一个牧场。

这两个牧场都在John的农场上。

John将会在两个牧场中各选一个牧区，然后用一条路径连起来，使得连通后这个新的更大的牧场有最小的直径。

注意，如果两条路径中途相交，我们不认为它们是连通的。

只有两条路径在同一个牧区相交，我们才认为它们是连通的。

现在请你编程找出一条连接两个不同牧场的路径，使得连上这条路径后，所有牧场（生成的新牧场和原有牧场）中直径最大的牧场的直径尽可能小。

输出这个直径最小可能值。

输入格式

第 1 行：一个整数 N, 表示牧区数；

第 2 到 N+1 行：每行两个整数 X,Y， 表示 N 个牧区的坐标。每个牧区的坐标都是不一样的。

第 N+2 行到第 2*N+1 行：每行包括 N 个数字 ( 0或1 ) 表示一个对称邻接矩阵。

例如，题目描述中的两个牧场的矩阵描述如下：

1
2
3
4
5
6
7
8
9
  A B C D E F G H 
A 0 1 0 0 0 0 0 0 
B 1 0 1 1 1 0 0 0 
C 0 1 0 0 1 0 0 0 
D 0 1 0 0 1 0 0 0 
E 0 1 1 1 0 0 0 0 
F 0 0 0 0 0 0 1 0 
G 0 0 0 0 0 1 0 1 
H 0 0 0 0 0 0 1 0

输入数据中至少包括两个不连通的牧区。

输出格式

只有一行，包括一个实数，表示所求答案。

数字保留六位小数。

数据范围

1≤N≤1501≤N≤150, 0≤X,Y≤1050≤X,Y≤105

输入样例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
8
10 10
15 10
20 10
15 15
20 15
30 15
25 10
30 10
01000000
10111000
01001000
01001000
01110000
00000010
00000101
00000010

输出样例：

1
22.071068

解决

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import java.util.*;
class PII{
    int x,y;
    public PII(int x,int y){
        this.x=x;
        this.y=y;
    }
}
public class Main{
    static int N=155,INF=(int)1e20;
    static int n;
    static PII[]q=new PII[N];
    static char[][]g=new char[N][N];
    static double[][]dist=new double[N][N];
    static double[]maxd=new double[N];
    public static double get_dist(PII i,PII j){
        int dx=i.x-j.x,dy=i.y-j.y;
        return (double)Math.sqrt(dx*dx+dy*dy);
    }
    public static void floyd(){
        for(int k=1;k<=n;k++)
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++){
                    dist[i][j]=Math.min(dist[i][j],dist[i][k]+dist[k][j]);
                }
    }
    public static void main(String[]args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        for(int i=1;i<=n;i++){
            int x=sc.nextInt();
            int y=sc.nextInt();
            q[i]=new PII(x,y);
        }
        for(int i=1;i<=n;i++){
            String s=sc.next();
            for(int j=1;j<=n;j++){
                g[i][j]=s.charAt(j-1);
            }
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i!=j){
                    if(g[i][j]=='1')dist[i][j]=get_dist(q[i],q[j]);
                    else dist[i][j]=INF;
                }
            }
        }
        floyd();
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(dist[i][j]<INF)
                    maxd[i]=Math.max(maxd[i],dist[i][j]);
            }
        }
        double res1=0;
        for(int i=1;i<=n;i++)res1=Math.max(res1,maxd[i]);
        double res2=INF;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(dist[i][j]>=INF){
                    res2=Math.min(res2,get_dist(q[i],q[j])+maxd[i]+maxd[j]);
                }
            }
        }
        System.out.printf("%.6f",Math.max(res1,res2));
    }
}
]]> <h2 id="星际旅行">星际旅行</h2> <h3 id="问题描述">问题描述</h3> <p>小明国庆节准备去某星系进行星际旅行，这个星系里一共有 n_n_ 个星球，其中布置了 m_m_ 道双向传送门，第 i_i_ 道传送门可以连接 ai,bi*a<strong>i_,_ 前缀和与差分 http://git.molittle.site/posts/77a88a6b.html 2025-04-02T14:34:59.000Z 2025-07-25T14:39:26.853Z 一维前缀和
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int q=sc.nextInt();
        int []a=new int[n+1];
        int []sum=new int[n+1];
        for(int i=1;i<=n;i++){
          a[i]=sc.nextInt();
          sum[i]=sum[i-1]+a[i];
        }
        for(int i=0;i<q;i++){
        int l=sc.nextInt();
        int r=sc.nextInt();
        System.out.println(sum[r]-sum[l-1]);
        }
        sc.close();
    }
}

二维前缀和

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
import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();
        int m=scan.nextInt();
        int q=scan.nextInt();
        int [][]a=new int[n+1][m+1];
        int [][]sum=new int[n+1][m+1];
        for(int i=1;i<=n;i++){
          for(int j=1;j<=m;j++){
            a[i][j]=scan.nextInt();
            sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+a[i][j];
          }
        }
        for(int i=0;i<q;i++){
          int x1=scan.nextInt();
          int y1=scan.nextInt();
          int x2=scan.nextInt();
          int y2=scan.nextInt();
          int res=sum[x2][y2]-sum[x1-1][y2]-sum[x2][y1-1]+sum[x1-1][y1-1];
          System.out.println(res);
        }
        scan.close();
    }
}

一维差分

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
import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();
        int q=scan.nextInt();
        int []a=new int[n+10];
        int []b=new int[n+10];
        int []c=new int[n+10];
        for(int i=1;i<=n;i++){
          a[i]=scan.nextInt();
          b[i]=a[i]-a[i-1];
        }
        for(int i=1;i<=q;i++){
          int l=scan.nextInt();
          int r=scan.nextInt();
          int d=scan.nextInt();
          b[l]+=d;
          b[r+1]-=d;
        }
        for(int i=1;i<=n;i++){
          c[i]=c[i-1]+b[i];
        }
        for(int i=1;i<=n;i++)
          System.out.print(c[i]+" ");
        scan.close();
    }
}

二维差分

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
import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();
        int m=scan.nextInt();
        int q=scan.nextInt();
        int [][]a=new int[n+10][m+10];
        int [][]b=new int[n+10][m+10];
        int [][]c=new int[n+10][m+10];

        for(int i=1;i<=n;i++){
          for(int j=1;j<=m;j++){
              a[i][j]=scan.nextInt();
              b[i][j]=a[i][j]-a[i-1][j]-a[i][j-1]+a[i-1][j-1];
          }
        }
        for(int i=1;i<=q;i++){
          int x1=scan.nextInt();
          int y1=scan.nextInt();
          int x2=scan.nextInt();
          int y2=scan.nextInt();
          int d=scan.nextInt();
          b[x1][y1]+=d;
          b[x2+1][y1]-=d;
          b[x1][y2+1]-=d;
          b[x2+1][y2+1]+=d;
        }
        for(int i=1;i<=n;i++){
          for(int j=1;j<=m;j++){
            b[i][j]=b[i][j]+b[i][j-1]+b[i-1][j]-b[i-1][j-1];
          }
        }
        for(int i=1;i<=n;i++){
          for(int j=1;j<=m;j++){
            System.out.print(b[i][j]+" ");
          }
          System.out.println();
        }
        scan.close();
    }
}
]]> <h3 id="一维前缀和">一维前缀和</h3> <figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line Dijkstra http://git.molittle.site/posts/9c98f56c.html 2025-03-12T11:31:06.000Z 2025-06-10T12:38:41.687Z Dijkstra 最小花费

题目描述

在 n 个人中，某些人的银行账号之间可以互相转账。这些人之间转账的手续费各不相同。给定这些人之间转账时需要从转账金额里扣除百分之几的手续费，请问 A 最少需要多少钱使得转账后 B 收到 100 元。

输入格式

第一行输入两个正整数 n,m，分别表示总人数和可以互相转账的人的对数。以下 m 行每行输入三个正整数 x,y,z，表示标号为 x 的人和标号为 y 的人之间互相转账需要扣除 z% 的手续费 ( z<100 )。最后一行输入两个正整数 A,B。数据保证 A 与 B 之间可以直接或间接地转账。**

输出格式

输出 A 使得 B 到账 100 元最少需要的总费用。 精确到小数点后 8 位。

数据范围

1≤n≤2000, m≤105

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import java.util.*;
public class Main{
    static int N=2010;
    static int M=100010;
    static int INF=0x3f3f3f3f;
    static int n,m,idx;
    static int A,B;
    static int []h=new int[N],e=new int[M*2];
    static int []ne=new int[M*2];
    static double []w=new double[M*2];
    static double []dist=new double[N];
    static boolean[]st=new boolean[N];
    public static void add(int a,int b,double c){
        e[idx]=b;
        w[idx]=c;
        ne[idx]=h[a];
        h[a]=idx++;
    }
    public static double dj(){
        Arrays.fill(dist,INF);
        dist[A]=100;
        PriorityQueue<PII>q=new PriorityQueue<>();
        q.offer(new PII(A,100));
        while(q.size()!=0){
            PII t=q.poll();
            int num=t.num;
            double distence=t.distence;
            if(st[num])continue;
            st[num]=true;
            for(int i=h[num];i!=-1;i=ne[i]){
                int j=e[i];
                if(dist[j]>distence/w[i]){
                    dist[j]=distence/w[i];
                    q.offer(new PII(j,dist[j]));
                }
            }
        }
        return dist[B];
    }
    public static void main(String[]args){
        Scanner scan=new Scanner(System.in);
        n=scan.nextInt();
        m=scan.nextInt();
        Arrays.fill(h,-1);
        while(m-->0){
            int a=scan.nextInt();
            int b=scan.nextInt();
            int c=scan.nextInt();
            double w=(1-(double)c/100);
            add(a,b,w);
            add(b,a,w);
        }
        A=scan.nextInt();
        B=scan.nextInt();
        double t=dj();
        System.out.printf("%.8f",t);
    }
}
class PII implements Comparable<PII>{
    int num;
    double distence;
    public PII(int num,double distence){
        this.num=num;
        this.distence=distence;
    }
    public int compareTo(PII o){
        return Double.compare(distence,o.distence);
    }
}
]]> <p><strong>Dijkstra</strong> <a href="https://www.acwing.com/problem/content/1128/" title="最小花费">最小花费</a></p> <h5 id="题目描述">题目描述</h5> <p>在 n 树状数组 http://git.molittle.site/posts/59a0de58.html 2025-03-08T14:14:35.000Z 2025-06-10T12:38:41.697Z 树状数组
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import java.util.*;
public class ttree {
    static int n,s;
    static int []a;
    static long res=0;
    static List<Integer>[]g;
    static int[]tr;
    static void modify(int i,int val) {
        while(i<=n) {
            tr[i]+=val;
            i+=i&-i;
        }
    }
    static int query(int i) {
        int sum=0;
        while(i>0) {
            sum+=tr[i];
            i-=i&-i;
        }
        return sum;
    }
    static int sum(int i) {
        return query(n)-query(i);
    }
    static void dfs(int u,int fa) {
        modify(a[u],1);
        for(int v:g[u]) {
            if(v!=fa) {
                dfs(v,u);
            }
        }
        for(int k=2;k*a[u]<=n;k++) {
            int t=k*a[u];
            res-=query(t)-query(t-1);
        }
        res+=sum(a[u]);
        modify(a[u], -1);
    }
//  static void dfs(int u, int p) {
//      int before = t0.query(a[u] - 1); // 进入 u 前，<a[u] 的节点数
//      t0.add(a[u], 1); // 记录 u
//      for (int v : g[u]) {
//          if (v != p) {
//              dfs(v, u); // 递归处理子节点
//          }
//      }
//      int after = t0.query(a[u] - 1); // 当前 <a[u] 的节点数（包括子树）
//      res += (after - before); // 新增的 <a[u] 的节点（即 u 的子节点中满足条件的）
//      t0.add(a[u], -1); // 回溯
//  }
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        n=scan.nextInt();
        s=scan.nextInt();
        a=new int[n+1];
        g=new ArrayList[n+1];
        tr=new int[n+1];
        Arrays.fill(tr,0);
        for(int i=1;i<=n;i++) {
            a[i]=scan.nextInt();
            g[i]=new ArrayList<>();
        }
        for(int i=0;i<n-1;i++) {
            int u=scan.nextInt();
            int v=scan.nextInt();
            g[u].add(v);
            g[v].add(u);
        }
        dfs(s,-1);
        System.out.println(res);
    }
}

楼兰壁画

树状数组

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import java.util.*;
import java.io.*;

class Tree {
    int[] tree;
    int N;

    public Tree(int N) {
        this.N = N;
        tree = new int[N + 1];
    }

    public int lowBit(int i) {
        return i & -i;
    }

    public void add(int i, int val) {
        while (i <= N) {
            tree[i] += val;
            i += lowBit(i);
        }
    }

    public int query(int i) {
        int res = 0;
        while (i > 0) {
            res += tree[i];
            i -= lowBit(i);
        }
        return res;
    }

    public int sum(int i) {
        return query(N) - query(i);
    }
}

public class Main {
    static int N = (int) 2e5 + 10;
    static int n;
    static int[] a = new int[N];
    static int[] up = new int[N];
    static int[] down = new int[N];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            a[i] = sc.nextInt();
        }

        Tree tree0 = new Tree(N);
        for (int i = 1; i <= n; i++) {
            int y = a[i];
            up[i] = tree0.sum(y); // 右边比当前元素大的数的个数
            down[i] = tree0.query(y - 1); // 左边比当前元素小的数的个数
            tree0.add(y, 1);
        }

        Arrays.fill(tree0.tree, 0); // 清空树状数组

        long res1 = 0, res2 = 0;
        for (int i = n; i >= 1; i--) {
            int y = a[i];
            res1 += up[i] * (long) tree0.sum(y); // 右边比当前元素大的数的个数乘以左边比当前元素大的数的个数
            res2 += down[i] * (long) tree0.query(y - 1); // 左边比当前元素小的数的个数乘以右边比当前元素小的数的个数
            tree0.add(y, 1);
        }

        System.out.println(res1 + " " + res2);
    }
}

一个树状数组问题

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
51
52
53
54
55
56
57
58
import java.io.*;
import java.util.*;
class Tree{
    long[]tree;
    int N;
    public Tree(int N){
        this.N=N;
        tree=new long[N+1];
    }
    public int lowBit(int i){
        return i&-i;
    }
    public void add(int i,int v){
        while(i<=N){
        tree[i]+=v;
        i+=lowBit(i);
        }
    }
    public long query(int i){
        long res=0;
        while(i>0){
        res+=tree[i];
        i-=lowBit(i);
        }
        return res;
    }
    public long sum(int i){
        return query(N)-query(i);
    }
}
public class Main{
    static int N=(int)1e5+10;
    static int []a=new int[N];
    static int n,m;
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        Tree tree0 = new Tree(N);
        n=sc.nextInt();
        m=sc.nextInt();
        for(int i=1;i<=n;i++){
            a[i]=sc.nextInt();
            tree0.add(i,a[i]-a[i-1]);
        }
        for(int i=0;i<m;i++){
            String s=sc.next();
            if(s.equals("Q")){
                int x=sc.nextInt();
                System.out.println(tree0.query(x));
            }else{
                int l=sc.nextInt();
                int r=sc.nextInt();
                int d=sc.nextInt();
                tree0.add(l,d);
                tree0.add(r+1,-d);
            }
        }
    } 
}
]]> <h3 id="树状数组">树状数组</h3> <figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">