人工智能数学基础实验（四）：最大似然估计的-AI 模型训练与参数优化

一、实验目标

• 理解最大似然估计（MLE）原理：掌握通过最大化数据出现概率估计模型参数的焦点头脑。
  
• 实现 MLE 与 AI 模型结合：使用 MLE 手动估计朴素贝叶斯模型参数，并与 Scikit-learn 内置模型对比，深入理解参数优化对分类性能的影响。
  
• 分析模型性能影响因素：探究训练集 / 测试集比例、特性数目对模型准确率、运行时间的影响，提升数据建模与调优本领。
  

二、实验要求

（一）数据预备

• 天生或加载二分类数据集，使用 Scikit-learn 的make_classification创建含 20 维特性的 1000 样本数据。
  
• 划分训练集与测试集，初始比例为 7:3。
  

（二）MLE 参数估计

• 假设特性服从高斯分布，手动计算各分类的均值、方差及先验概率。
  
• 推导后验概率公式，实现基于 MLE 的朴素贝叶斯分类器。
  

（三）模型构建与对比

• 手动实现：基于 MLE 参数的朴素贝叶斯分类器，对新样本举行分类猜测。
  
• Scikit-learn 对比：使用GaussianNB内置模型，比力两者的准确率、准确率、召回率及运行时间。
  

（四）性能分析

• 调整测试集比例（0.2~0.5），观察模型稳定性。
  
• 改变特性数目（10~50），分析特性维度对模型性能的影响。
  

三、实验原理

四、实验步骤

（一）数据天生与预处理

1. import numpy as np  
2. from sklearn.datasets import make_classification  
3. # 生成二分类数据集  
4. X, y = make_classification(  
5.     n_samples=1000, n_features=20, n_classes=2, random_state=42  
6. )  
7. # 划分训练集与测试集（初始比例7:3）  
8. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)  

复制代码

（二）手动实现 MLE 与朴素贝叶斯

1. class ManualNaiveBayes:  
2.     def fit(self, X, y):  
3.         self.classes = np.unique(y)  
4.         self.params = {}  
5.         for c in self.classes:  
6.             X_c = X[y == c]  
7.             self.params[c] = {  
8.                 'mean': np.mean(X_c, axis=0),  # 均值  
9.                 'var': np.var(X_c, axis=0),    # 方差  
10.                 'prior': len(X_c) / len(X)     # 先验概率  
11.             }  
12.     def predict(self, X):  
13.         posteriors = []  
14.         for c in self.classes:  
15.             prior = np.log(self.params[c]['prior'])  
16.             mean = self.params[c]['mean']  
17.             var = self.params[c]['var']  
18.             # 计算对数似然  
19.             likelihood = -0.5 * np.sum(np.log(2 * np.pi * var)) - 0.5 * np.sum(((X - mean)**2)/var, axis=1)  
20.             posterior = prior + likelihood  
21.             posteriors.append(posterior)  
22.         return self.classes[np.argmax(posteriors, axis=0)]  # 选择后验概率最大的类别  

复制代码

（三）模型训练与对比

1. from sklearn.naive_bayes import GaussianNB  
2. from sklearn.metrics import accuracy_score  
4. # 手动模型训练与预测  
5. manual_nb = ManualNaiveBayes()  
6. manual_nb.fit(X_train, y_train)  
7. y_pred_manual = manual_nb.predict(X_test)  
9. # Scikit-learn模型训练与预测  
10. sklearn_nb = GaussianNB()  
11. sklearn_nb.fit(X_train, y_train)  
12. y_pred_sklearn = sklearn_nb.predict(X_test)  
14. # 性能指标计算  
15. print(f"手动实现准确率：{accuracy_score(y_test, y_pred_manual):.4f}")  
16. print(f"Sklearn实现准确率：{accuracy_score(y_test, y_pred_sklearn):.4f}")  

复制代码

（四）参数调优与分析

• 测试集比例影响：循环测试test_size=[0.2, 0.3, 0.4, 0.5]，发现两者准确率波动较小（手动实现约 0.69~0.71，Scikit-learn 约 0.70~0.72），但 Scikit-learn 在测试集比例较大时稳定性略优。
  
• 特性数目影响：特性数从 10 增至 30 时，准确率上升（峰值约 0.73）；超过 30 后因过拟合降落。手动实现运行时间随特性数呈平方级增长，Scikit-learn 因底层优化增长迟钝。
  

（五）完整源代码

1. import numpy as np
2. from sklearn.model_selection import train_test_split
3. from sklearn.naive_bayes import GaussianNB
4. from sklearn.metrics import accuracy_score, precision_score, recall_score
5. import matplotlib.pyplot as plt
6. from sklearn.datasets import make_classification
7. import time
9. plt.rcParams['font.sans-serif'] = ['SimHei']
10. plt.rcParams['axes.unicode_minus'] = False
11. # 1. 数据加载与预处理
12. # 生成随机二分类数据集
13. X, y = make_classification(
14.     n_samples=1000,  # 样本数量
15.     n_features=20,  # 特征数量
16.     n_classes=2,  # 类别数量
17.     n_informative=15,  # 有信息量的特征数量
18.     n_redundant=3,  # 冗余特征数量
19.     n_repeated=2,  # 重复特征数量
20.     class_sep=0.5,  # 类别之间的分离程度
21.     random_state=42
22. )
24. # 划分训练集和测试集
25. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
27. # 2. 手动实现MLE估计（朴素贝叶斯）
28. class ManualNaiveBayes:
29.     def fit(self, X, y):
30.         self.classes = np.unique(y)
31.         self.params = {}
32.         for c in self.classes:
33.             X_c = X[y == c]
34.             self.params[c] = {
35.                 'mean': np.mean(X_c, axis=0),
36.                 'var': np.var(X_c, axis=0),
37.                 'prior': len(X_c) / len(X)
38.             }
40.     def predict(self, X):
41.         X = np.array(X)  # 确保输入是numpy数组
42.         posteriors = []
43.         for c in self.classes:
44.             prior = np.log(self.params[c]['prior'])
45.             mean = self.params[c]['mean']
46.             var = self.params[c]['var']
47.             likelihood = -0.5 * np.sum(np.log(2 * np.pi * var)) - 0.5 * np.sum(((X - mean) ** 2) / var, axis=1)
48.             posterior = prior + likelihood
49.             posteriors.append(posterior)
50.         return self.classes[np.argmax(posteriors, axis=0)]
52. # 3. 使用sklearn的朴素贝叶斯对比
53. # 手动实现模型
54. manual_nb = ManualNaiveBayes()
55. start_time = time.time()
56. manual_nb.fit(X_train, y_train)
57. y_pred_manual = manual_nb.predict(X_test)
58. manual_time = time.time() - start_time
60. # sklearn模型
61. sklearn_nb = GaussianNB()
62. start_time = time.time()
63. sklearn_nb.fit(X_train, y_train)
64. y_pred_sklearn = sklearn_nb.predict(X_test)
65. sklearn_time = time.time() - start_time
67. # 4. 结果可视化输出
68. # 绘制原始数据分布
69. plt.figure(figsize=(12, 6))
70. plt.subplot(1, 3, 1)
71. plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', marker='o')
72. plt.title('原始数据分布')
73. plt.xlabel('特征1')
74. plt.ylabel('特征2')
76. # 绘制手动实现模型的分类结果
77. plt.subplot(1, 3, 2)
78. plt.scatter(X_test[:, 0], X_test[:, 1], c=y_pred_manual, edgecolors='k', marker='o')
79. plt.title('手动实现分类结果')
80. plt.xlabel('特征1')
81. plt.ylabel('特征2')
83. # 绘制sklearn模型的分类结果
84. plt.subplot(1, 3, 3)
85. plt.scatter(X_test[:, 0], X_test[:, 1], c=y_pred_sklearn, edgecolors='k', marker='o')
86. plt.title('sklearn分类结果')
87. plt.xlabel('特征1')
88. plt.ylabel('特征2')
90. plt.tight_layout()
91. plt.show()
93. # 5. 终端输出性能指标
94. # 计算手动实现的模型性能指标
95. manual_acc = accuracy_score(y_test, y_pred_manual)
96. manual_pre = precision_score(y_test, y_pred_manual)
97. manual_rec = recall_score(y_test, y_pred_manual)
99. # 计算sklearn模型性能指标
100. sklearn_acc = accuracy_score(y_test, y_pred_sklearn)
101. sklearn_pre = precision_score(y_test, y_pred_sklearn)
102. sklearn_rec = recall_score(y_test, y_pred_sklearn)
104. print("手动实现的朴素贝叶斯分类器：")
105. print(f"准确率：{manual_acc:.4f}")
106. print(f"精确率：{manual_pre:.4f}")
107. print(f"召回率：{manual_rec:.4f}")
108. print(f"运行时间：{manual_time:.4f}秒")
110. print("\n使用sklearn的高斯朴素贝叶斯分类器：")
111. print(f"准确率：{sklearn_acc:.4f}")
112. print(f"精确率：{sklearn_pre:.4f}")
113. print(f"召回率：{sklearn_rec:.4f}")
114. print(f"运行时间：{sklearn_time:.4f}秒")
116. # 6. 不同训练集/测试集比例下的性能指标变化分析
117. test_sizes = [0.2, 0.3, 0.4, 0.5]
118. manual_accs = []
119. sklearn_accs = []
120. manual_times = []
121. sklearn_times = []
123. for test_size in test_sizes:
124.     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)
126.     # 手动实现模型
127.     manual_nb = ManualNaiveBayes()
128.     start_time = time.time()
129.     manual_nb.fit(X_train, y_train)
130.     y_pred_manual = manual_nb.predict(X_test)
131.     manual_acc = accuracy_score(y_test, y_pred_manual)
132.     manual_time = time.time() - start_time
133.     manual_accs.append(manual_acc)
134.     manual_times.append(manual_time)
136.     # sklearn模型
137.     sklearn_nb = GaussianNB()
138.     start_time = time.time()
139.     sklearn_nb.fit(X_train, y_train)
140.     y_pred_sklearn = sklearn_nb.predict(X_test)
141.     sklearn_acc = accuracy_score(y_test, y_pred_sklearn)
142.     sklearn_time = time.time() - start_time
143.     sklearn_accs.append(sklearn_acc)
144.     sklearn_times.append(sklearn_time)
146. # 绘制不同测试集比例下的准确率变化
147. plt.figure(figsize=(12, 6))
148. plt.subplot(1, 2, 1)
149. plt.plot(test_sizes, manual_accs,color='red',marker='o',label='手动实现')
150. plt.plot(test_sizes, sklearn_accs,color='green', label='sklearn实现')
151. plt.xlabel('测试集比例')
152. plt.ylabel('准确率')
153. plt.title('不同测试集比例下的准确率变化')
154. plt.legend()
155. plt.grid(True)
157. # 绘制不同测试集比例下的运行时间变化
158. plt.subplot(1, 2, 2)
159. plt.plot(test_sizes, manual_times, marker='o', label='手动实现')
160. plt.plot(test_sizes, sklearn_times, marker='o', label='sklearn实现')
161. plt.xlabel('测试集比例')
162. plt.ylabel('运行时间（秒）')
163. plt.title('不同测试集比例下的运行时间变化')
164. plt.legend()
165. plt.grid(True)
167. plt.tight_layout()
168. plt.show()

复制代码

五、实验结果

（一）基础性能对比

模型类型准确率准确率召回率运行时间（秒）手动实现（MLE）0.69670.72790.64710.0009Scikit-learn0.69670.72790.64710.0020

（二）关键结论

• MLE 的有用性：手动实现成功通过 MLE 估计参数，验证了朴素贝叶斯的分类逻辑，但细节优化不敷（如未处理数值稳定性）。
  
• 库函数上风：Scikit-learn 的GaussianNB在雷同准确率下更高效稳定，得当现实应用；手动实现得当学习算法原理。
  
• 特性与数据划分：特性数适中（20~30 维）时模型最佳，过多需降维；测试集比例对结果影响较小，建议使用交叉验证提升可靠性。
  

六、总结

   本次实验通过手动实现 MLE 与朴素贝叶斯分类器，深入理解了参数估计的数学原理，并对比了 Scikit-learn 库函数的性能。结果表明，MLE 是毗连统计理论与呆板学习的重要桥梁，而成熟库函数在工程实践中更具上风。未来可进一步优化手动代码（如向量化计算、正则化），或探索 MLE 在其他模型（如逻辑回归）中的应用。