哈喽，我是kk~
这几天发现很多初学者的群里在聊一些，关于机器学习基础的话题。
那么，今天我给大家详细的总结了关于机器学习核心算法的介绍和案例，文章很长，建议大家收藏起来慢慢学习~
以下十大机器学习算法是咱们今天要介绍的，也是建议大家熟练搞懂的~
线性回归
逻辑回归
决策树
支持向量机
朴素贝叶斯
K近邻算法
K均值聚类
AdaBoost
随机森林
梯度提升机
线性回归
线性回归是一种用于建立输入特征与连续输出之间关系的线性模型。它假设特征和输出之间存在线性关系，并试图找到最佳拟合直线（在一维情况下）或超平面（在多维情况下）来描述这种关系。
核心原理
线性回归的核心思想是使用最小二乘法来拟合数据，即找到一条直线或超平面，使得所有数据点到这条直线或超平面的距离之和最小。这条直线或超平面的方程可以表示为：，其中
是预测值，
是模型参数，
是特征。
公式推理
假设有
个训练样本，每个样本包含
个特征，则我们可以将线性回归的模型表示为：
，其中
是
的矩阵，每一行是一个样本的特征（包括一个常数项1），
是
的参数向量。最小化平方误差函数，对
求导可得最优参数
。
优缺点和适用场景
优点：简单易懂，计算速度快，适用于线性关系较强的数据。
缺点：对异常值敏感，只能建模线性关系，不能处理非线性数据。
适用场景：预测房价、销售量等连续型变量的场景。
Python案例
import numpy as npimport matplotlib.pyplot as pltfrom sklearn.linear_model import LinearRegressionfrom sklearn.tree import DecisionTreeRegressorfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import mean_squared_error# 创建一个具有一些线性关系的示例数据np.random.seed(0)X = np.random.rand(100, 1)y = 2.5 + 3.7 * X.squeeze() + np.random.normal(0, 0.2, 100)# 拆分数据集X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# 使用线性回归模型进行拟合lr = LinearRegression()lr.fit(X_train, y_train)# 使用决策树回归模型进行拟合dt = DecisionTreeRegressor(max_depth=3)dt.fit(X_train, y_train)# 生成预测数据X_range = np.linspace(0, 1, 100).reshape(-1, 1)# 绘制数据点和拟合直线plt.figure(figsize=(10, 6))plt.scatter(X, y, c='b', label='Data')plt.plot(X_range, lr.predict(X_range), c='r', label='Linear Regression')plt.plot(X_range, dt.predict(X_range), c='g', label='Decision Tree Regressor')plt.xlabel('X')plt.ylabel('y')plt.title('Comparison of Linear Regression and Decision Tree Regressor')plt.legend()plt.show()# 输出模型的均方误差print("Linear Regression MSE:", mean_squared_error(y_test, lr.predict(X_test)))print("Decision Tree Regressor MSE:", mean_squared_error(y_test, dt.predict(X_test)))# Linear Regression MSE: 0.04173733526278079# Decision Tree Regressor MSE: 0.08183143313116807
代码中，比较了线性回归模型和决策树回归模型在相同数据集上的表现，并绘制了数据点和两种模型的拟合直线，体现了线性回归模型在处理线性关系数据方面的优势。
逻辑回归
逻辑回归是一种用于建立输入特征和二元输出之间概率关系的模型。虽然名字中有“回归”，但实际上逻辑回归是一种分类算法，用于预测二元变量的概率。
核心原理
逻辑回归使用逻辑函数（也称为Sigmoid函数）将线性组合的特征映射到0到1之间的概率值。Sigmoid函数的公式为：
，其中是线性组合的结果。概率预测为1的概率为，其中
是模型的预测函数。
公式推理
假设有
个训练样本，每个样本包含
个特征，则我们可以将逻辑回归的模型表示为：
，其中
是
的矩阵，每一行是一个样本的特征（包括一个常数项1），
是
的参数向量。最小化逻辑回归的损失函数，可以使用梯度下降等方法求解最优参数
。
优缺点和适用场景
优点：简单易懂，计算速度快，适用于二元分类问题。
缺点：只能处理二元分类问题，对特征空间中的线性关系较强。
适用场景：预测学生是否通过考试、邮件是否为垃圾邮件等二元分类问题。
Python案例
import numpy as npimport matplotlib.pyplot as pltfrom sklearn.linear_model import LogisticRegressionfrom sklearn.tree import DecisionTreeClassifierfrom sklearn.datasets import make_classificationfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score# 创建一个具有一些线性关系的二分类示例数据X, y = make_classification(n_samples=100, n_features=3, n_informative=2, n_redundant=0, n_repeated=0, n_classes=2, n_clusters_per_class=1, random_state=0)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# 使用逻辑回归模型进行拟合lr = LogisticRegression()lr.fit(X_train, y_train)# 使用决策树分类模型进行拟合dt = DecisionTreeClassifier(max_depth=3)dt.fit(X_train, y_train)# 绘制数据点和决策边界x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np.linspace(y_min, y_max, 100))Z_lr = lr.predict(np.c_[xx.ravel(), yy.ravel(), np.zeros_like(xx.ravel())]).reshape(xx.shape)Z_dt = dt.predict(np.c_[xx.ravel(), yy.ravel(), np.zeros_like(xx.ravel())]).reshape(xx.shape)plt.figure(figsize=(12, 6))plt.subplot(1, 2, 1)plt.contourf(xx, yy, Z_lr, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Logistic Regression")plt.subplot(1, 2, 2)plt.contourf(xx, yy, Z_dt, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Decision Tree Classifier")plt.show()# 输出模型的准确率print("Logistic Regression Accuracy:", accuracy_score(y_test, lr.predict(X_test)))print("Decision Tree Classifier Accuracy:", accuracy_score(y_test, dt.predict(X_test)))
比较了逻辑回归模型和决策树分类模型在相同数据集上的表现，并绘制了数据点和两种模型的决策边界，体现了逻辑回归模型在处理线性关系数据和二元分类问题方面的优势。
决策树
决策树是一种基于树结构来进行分类和回归的模型。它通过对数据集的特征进行划分，构建一个树形结构，每个叶子节点代表一个类别或者一个数值。
核心原理
决策树的核心思想是根据特征的信息增益或信息增益比来选择最优特征进行划分，直到所有数据点都被正确分类或者达到停止条件为止。在分类问题中，叶子节点表示一个类别，在回归问题中，叶子节点表示一个数值。
公式推理
假设有
个训练样本，每个样本包含
个特征，决策树的构建过程包括特征选择、树的生成和树的剪枝。特征选择通常使用信息增益或信息增益比来衡量，树的生成使用递归分割数据集，树的剪枝是为了防止过拟合。
优缺点和适用场景
优点：易于理解和解释，能够处理数值和分类数据，对缺失值不敏感，能够处理多输出问题。
缺点：容易过拟合，对数据中的噪声敏感。
适用场景：适用于各种数据类型的分类和回归问题，特别是特征之间有明显关联性的问题。
Python案例
import numpy as npimport matplotlib.pyplot as pltfrom sklearn.tree import DecisionTreeClassifier, plot_treefrom sklearn.linear_model import LogisticRegressionfrom sklearn.datasets import make_classificationfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score# 创建一个具有一些非线性关系的二分类示例数据X, y = make_classification(n_samples=100, n_features=2, n_classes=2, n_clusters_per_class=1, random_state=0)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# 使用决策树分类模型进行拟合dt = DecisionTreeClassifier(max_depth=3)dt.fit(X_train, y_train)# 使用逻辑回归模型进行拟合lr = LogisticRegression()lr.fit(X_train, y_train)# 绘制数据点和决策树的决策边界plt.figure(figsize=(12, 6))plt.subplot(1, 2, 1)plot_tree(dt, filled=True, rounded=True, class_names=['0', '1'])plt.title("Decision Tree Classifier")# 绘制数据点和逻辑回归的决策边界plt.subplot(1, 2, 2)h = .02 # 网格中的步长x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))Z_lr = lr.predict(np.c_[xx.ravel(), yy.ravel(), np.zeros_like(xx.ravel())]).reshape(xx.shape)plt.contourf(xx, yy, Z_lr, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Logistic Regression")plt.show()# 输出模型的准确率print("Decision Tree Classifier Accuracy:", accuracy_score(y_test, dt.predict(X_test)))print("Logistic Regression Accuracy:", accuracy_score(y_test, lr.predict(X_test)))
比较了决策树分类模型和逻辑回归模型在相同数据集上的表现，并绘制了决策树的决策边界和逻辑回归的决策边界，体现了决策树模型在处理非线性关系数据方面的优势。
支持向量机
支持向量机是一种用于分类和回归分析的监督学习模型，它可以在高维空间中进行数据分类。在分类问题中，SVM找到一个最优的超平面来分隔不同类别的数据点。
核心原理
SVM的核心思想是找到一个最大间隔超平面，即距离两个类别最近的样本点的距离最大化。对于线性可分的情况，最大间隔超平面可以表示为
，其中
是法向量，
是截距。对于非线性可分的情况，SVM使用核技巧将数据映射到高维空间中进行分类。
公式推理
假设有
个训练样本，每个样本包含
个特征，SVM的优化问题可以表示为：
，约束条件为
。使用拉格朗日乘子法求解得到最优解。
优缺点和适用场景
优点：能够处理高维数据，泛化能力强，可以处理非线性问题。
缺点：对于大规模数据集，训练时间较长，对参数和核函数的选择敏感。
适用场景：适用于二元分类问题，特别是在数据维度较高的情况下。
Python案例
import numpy as npimport matplotlib.pyplot as pltfrom sklearn.svm import SVCfrom sklearn.linear_model import LogisticRegressionfrom sklearn.datasets import make_blobsfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score# 创建一个具有一些非线性关系的二分类示例数据X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=0)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# 使用支持向量机进行拟合svm = SVC(kernel='linear')svm.fit(X_train, y_train)# 使用逻辑回归进行拟合lr = LogisticRegression()lr.fit(X_train, y_train)# 绘制数据点和决策边界x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))Z_svm = svm.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)Z_lr = lr.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)plt.figure(figsize=(12, 6))plt.subplot(1, 2, 1)plt.contourf(xx, yy, Z_svm, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Support Vector Machine")plt.subplot(1, 2, 2)plt.contourf(xx, yy, Z_lr, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Logistic Regression")plt.show()# 输出模型的准确率print("Support Vector Machine Accuracy:", accuracy_score(y_test, svm.predict(X_test)))print("Logistic Regression Accuracy:", accuracy_score(y_test, lr.predict(X_test)))
在这个示例中，我们比较了支持向量机模型和逻辑回归模型在相同数据集上的表现，并绘制了两种模型的决策边界，体现了支持向量机模型在处理非线性关系数据和高维数据方面的优势。
朴素贝叶斯
朴素贝叶斯是一种基于贝叶斯定理和特征条件独立假设的简单概率分类器。尽管其“朴素”假设可能过于简化现实情况，但在实际应用中表现良好。
核心原理
朴素贝叶斯假设特征之间相互独立，即给定类别，特征之间的关系是不存在的。根据贝叶斯定理，朴素贝叶斯计算每个类别的后验概率，并选择具有最高概率的类别作为预测结果。
公式推理
假设有类别集合
，特征集合
，朴素贝叶斯模型假设特征之间独立，则后验概率可以表示为，其中
为常数，可以忽略，因此最终预测的类别为。
优缺点和适用场景
优点：简单快速，对小规模数据表现良好，对缺失数据不敏感，适用于多分类问题。
缺点：假设特征相互独立，可能不符合实际情况，表现受特征间相关性影响。
适用场景：文本分类、垃圾邮件识别等简单分类问题，尤其是特征间关联性较弱的场景。
Python案例
import numpy as npimport matplotlib.pyplot as pltfrom sklearn.datasets import make_classificationfrom sklearn.model_selection import train_test_splitfrom sklearn.naive_bayes import GaussianNBfrom sklearn.linear_model import LogisticRegressionfrom sklearn.metrics import accuracy_score# 创建一个具有一些线性关系的二分类示例数据X, y = make_classification(n_samples=100, n_features=3, n_informative=2, n_redundant=0, n_repeated=0, n_classes=2, n_clusters_per_class=1, random_state=0)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# 使用前两个特征进行绘制和拟合X_train_2d, X_test_2d = X_train[:, :2], X_test[:, :2]# 使用朴素贝叶斯进行拟合nb = GaussianNB()nb.fit(X_train_2d, y_train)# 使用逻辑回归进行拟合lr = LogisticRegression()lr.fit(X_train_2d, y_train)# 绘制数据点和决策边界x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))Z_nb = nb.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)Z_lr = lr.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)plt.figure(figsize=(12, 6))plt.subplot(1, 2, 1)plt.contourf(xx, yy, Z_nb, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Naive Bayes")plt.subplot(1, 2, 2)plt.contourf(xx, yy, Z_lr, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Logistic Regression")plt.show()# 输出模型的准确率print("Naive Bayes Accuracy:", accuracy_score(y_test, nb.predict(X_test_2d)))print("Logistic Regression Accuracy:", accuracy_score(y_test, lr.predict(X_test_2d)))
在这个示例中，我们比较了朴素贝叶斯模型和逻辑回归模型在相同数据集上的表现，并绘制了朴素贝叶斯模型的决策边界和逻辑回归模型的决策边界，体现了朴素贝叶斯模型在处理简单分类问题方面的优势。
K近邻算法
K近邻算法是一种基于实例的学习方法，用于分类和回归。在分类问题中，对于一个未知类别的样本，通过与其最近邻的K个训练样本的类别来决定其类别。在回归问题中，通过与其最近邻的K个训练样本的数值来预测其数值。
核心原理
K近邻算法基于一个简单的假设：相似的样本在特征空间中具有相似的类别。算法的核心思想是找到与待预测样本最近的K个训练样本，然后根据这K个样本的类别（或数值）来预测待预测样本的类别（或数值）。
公式推理
假设有一个未知样本
，距离度量为欧式距离，距离公式为，其中
是第
个训练样本的第
个特征值，
是未知样本的第
个特征值。找到离
最近的K个训练样本，根据它们的类别（或数值）来预测
的类别（或数值）。
优缺点和适用场景
优点：简单易懂，无需训练阶段，适用于小型数据集。
缺点：对于大型数据集，计算量较大，需要存储所有训练样本，预测速度较慢。
适用场景：适用于样本量不大的分类问题，特别是类别之间较为密集的情况。
Python案例
import numpy as npimport matplotlib.pyplot as pltfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn.linear_model import LogisticRegressionfrom sklearn.datasets import make_classificationfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score# 创建一个具有一些线性关系的二分类示例数据X, y = make_classification(n_samples=100, n_features=4, n_informative=2, n_redundant=0, n_classes=2, n_clusters_per_class=1, random_state=0)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# 使用K近邻算法进行拟合knn = KNeighborsClassifier(n_neighbors=3)knn.fit(X_train, y_train)# 使用逻辑回归进行拟合lr = LogisticRegression()lr.fit(X_train, y_train)# 绘制数据点和决策边界x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))Z_knn = knn.predict(np.c_[xx.ravel(), yy.ravel(), np.zeros_like(xx.ravel()), np.zeros_like(xx.ravel())]).reshape(xx.shape)Z_lr = lr.predict(np.c_[xx.ravel(), yy.ravel(), np.zeros_like(xx.ravel()), np.zeros_like(xx.ravel())]).reshape(xx.shape)plt.figure(figsize=(12, 6))plt.subplot(1, 2, 1)plt.contourf(xx, yy, Z_knn, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("K Nearest Neighbors")plt.subplot(1, 2, 2)plt.contourf(xx, yy, Z_lr, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Logistic Regression")plt.show()# 输出模型的准确率print("K Nearest Neighbors Accuracy:", accuracy_score(y_test, knn.predict(X_test)))print("Logistic Regression Accuracy:", accuracy_score(y_test, lr.predict(X_test)))
比较了K近邻算法模型和逻辑回归模型在相同数据集上的表现，并绘制了K近邻算法模型的决策边界和逻辑回归模型的决策边界，体现了K近邻算法模型在处理简单分类问题方面的优势。
K均值聚类
K均值聚类是一种常用的无监督学习算法，用于将数据集划分为K个不同的组或簇。每个数据点都属于距离其最近的簇中心，这些簇中心通过迭代地计算得到，直到簇内数据点的平方误差和收敛为止。
核心原理
选择K个初始簇中心。
将每个数据点分配到距离其最近的簇中心。
更新每个簇的中心为该簇所有数据点的平均值。
重复步骤2和3，直到簇内数据点的平方误差和收敛或达到最大迭代次数。
公式推理
假设有数据集
，簇中心集合
，则簇
的平方误差为
，总平方误差为。
优缺点和适用场景
优点：简单易懂，计算速度快，适用于大型数据集。
缺点：需要提前确定簇的数量K，对初始簇中心的选择敏感，可能收敛到局部最优解。
适用场景：适用于聚类数量已知或有一定先验知识的情况，适用于数据集各个簇的形状相对简单的情况。
Python案例
import numpy as npimport matplotlib.pyplot as pltfrom sklearn.datasets import make_blobsfrom sklearn.cluster import KMeansfrom sklearn.metrics import silhouette_score# 创建一个示例数据集X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)# 使用K均值聚类进行拟合kmeans = KMeans(n_clusters=4, random_state=0)y_kmeans = kmeans.fit_predict(X)# 绘制数据点和聚类中心plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap='viridis')plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s=200, c='red', alpha=0.5)plt.show()# 输出聚类的轮廓系数print("Silhouette Score:", silhouette_score(X, y_kmeans))
使用K均值聚类将示例数据集分为4个簇，并绘制了数据点和聚类中心的分布。同时，计算并输出了聚类的轮廓系数，用于评估聚类的效果，值越接近1表示聚类效果越好。
AdaBoost
AdaBoost是一种集成学习方法，通过组合多个弱学习器来构建一个强学习器。它通过迭代地训练一系列弱分类器，并调整样本权重，使得在前一个分类器分类错误的样本在下一个分类器中得到更多关注，从而提高模型的准确性。
核心原理
AdaBoost的核心原理是通过迭代训练一系列弱分类器，在每一轮迭代中调整样本权重，使得前一轮分类错误的样本在下一轮中得到更多的关注。最终的预测结果是所有弱分类器的加权和，权重取决于各自分类器的准确性。
公式推理
假设有
个弱分类器，每个弱分类器的权重为
，最终的预测结果为，其中
是第
个弱分类器的预测结果。在每一轮迭代中，样本的权重
被更新为，其中
是样本
的真实类别。
优缺点和适用场景
优点：能够处理高维数据和大规模数据集，不容易过拟合，泛化能力强。
缺点：对噪声和异常值敏感，训练时间较长。
适用场景：适用于二分类和多分类问题，特别是在处理复杂数据集和不平衡数据集时效果显著。
Python案例
import numpy as npimport matplotlib.pyplot as pltfrom sklearn.ensemble import AdaBoostClassifierfrom sklearn.linear_model import LogisticRegressionfrom sklearn.datasets import make_classificationfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score# 创建一个具有一些线性关系的二分类示例数据，特征数量为3X, y = make_classification(n_samples=100, n_features=3, n_classes=2, n_clusters_per_class=1, n_informative=2, n_redundant=0, n_repeated=0, random_state=0)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# 使用AdaBoost进行拟合ada = AdaBoostClassifier(n_estimators=50, random_state=0)ada.fit(X_train, y_train)# 使用逻辑回归进行拟合lr = LogisticRegression()lr.fit(X_train, y_train)# 绘制数据点和决策边界x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))Z_ada = ada.predict(np.c_[xx.ravel(), yy.ravel(), np.zeros_like(xx.ravel())]).reshape(xx.shape)Z_lr = lr.predict(np.c_[xx.ravel(), yy.ravel(), np.zeros_like(xx.ravel())]).reshape(xx.shape)plt.figure(figsize=(12, 6))plt.subplot(1, 2, 1)plt.contourf(xx, yy, Z_ada, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("AdaBoost")plt.subplot(1, 2, 2)plt.contourf(xx, yy, Z_lr, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Logistic Regression")plt.show()# 输出模型的准确率print("AdaBoost Accuracy:", accuracy_score(y_test, ada.predict(X_test)))print("Logistic Regression Accuracy:", accuracy_score(y_test, lr.predict(X_test)))
比较了AdaBoost模型和逻辑回归模型在相同数据集上的表现，并绘制了AdaBoost模型的决策边界和逻辑回归模型的决策边界，体现了AdaBoost模型在处理复杂分类问题方面的优势。
随机森林
随机森林是一种集成学习方法，通过构建多个决策树来解决分类和回归问题。它通过对每个决策树的预测结果进行平均或投票来提高模型的准确性。
核心原理
随机森林的核心原理是通过随机选择样本和特征来构建多棵决策树，并且通过减少过拟合来提高模型的泛化能力。在分类问题中，最终的预测结果是所有决策树预测结果的投票结果；在回归问题中，最终的预测结果是所有决策树预测结果的平均值。
公式推理
对于分类问题，假设有
棵树，
个类别，第
棵树的预测结果为
，则随机森林的最终预测结果为，其中
为指示函数。对于回归问题，最终预测结果为
。
优缺点和适用场景
优点：能够处理大量高维数据，不容易过拟合，对缺失值和异常值鲁棒。
缺点：模型解释性较差，训练和预测速度较慢。
适用场景：适用于各种类型的分类和回归问题，特别是处理大规模数据集和高维数据。
Python案例
import numpy as npimport matplotlib.pyplot as pltfrom sklearn.ensemble import RandomForestClassifierfrom sklearn.linear_model import LogisticRegressionfrom sklearn.datasets import make_classificationfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score# 创建一个具有一些线性关系的二分类示例数据X, y = make_classification(n_samples=100, n_features=2, n_classes=2, n_clusters_per_class=1, n_informative=2, n_redundant=0, n_repeated=0, random_state=0)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# 使用随机森林进行拟合rf = RandomForestClassifier(n_estimators=100, random_state=0)rf.fit(X_train, y_train)# 使用逻辑回归进行拟合lr = LogisticRegression()lr.fit(X_train, y_train)# 绘制数据点和决策边界x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))Z_rf = rf.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)Z_lr = lr.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)plt.figure(figsize=(12, 6))plt.subplot(1, 2, 1)plt.contourf(xx, yy, Z_rf, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Random Forest")plt.subplot(1, 2, 2)plt.contourf(xx, yy, Z_lr, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Logistic Regression")plt.show()# 输出模型的准确率print("Random Forest Accuracy:", accuracy_score(y_test, rf.predict(X_test)))print("Logistic Regression Accuracy:", accuracy_score(y_test, lr.predict(X_test)))
比较了随机森林模型和逻辑回归模型在相同数据集上的表现，并绘制了随机森林模型的决策边界和逻辑回归模型的决策边界，体现了随机森林模型在处理复杂分类问题方面的优势。
梯度提升机
梯度提升机是一种集成学习方法，通过迭代地训练决策树来提高模型的准确性。与AdaBoost不同的是，梯度提升机通过最小化损失函数的梯度来训练模型，从而减少残差。
核心原理
梯度提升机的核心原理是通过迭代地训练决策树来逐步减少残差。在每一轮迭代中，新的决策树被训练以最小化损失函数的负梯度。最终的预测结果是所有决策树的加权和。
公式推理
假设有
个决策树，每个决策树的预测结果为
，则梯度提升机的最终预测结果为
，其中
是第
个决策树的权重。在每一轮迭代中，损失函数的负梯度被用来训练新的决策树。
优缺点和适用场景
优点：能够处理各种类型的数据，对异常值鲁棒，泛化能力强。
缺点：相对于其他模型，训练时间较长，需要仔细调参。
适用场景：适用于回归和分类问题，特别是在处理结构化数据和表现良好的特征集时效果显著。
Python案例
import numpy as npimport matplotlib.pyplot as pltfrom sklearn.ensemble import GradientBoostingClassifierfrom sklearn.linear_model import LogisticRegressionfrom sklearn.datasets import make_classificationfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score# 创建一个具有一些线性关系的二分类示例数据X, y = make_classification(n_samples=100, n_features=2, n_classes=2, n_clusters_per_class=1, random_state=0)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)# 使用梯度提升机进行拟合gbm = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, random_state=0)gbm.fit(X_train, y_train)# 使用逻辑回归进行拟合lr = LogisticRegression()lr.fit(X_train, y_train)# 绘制数据点和决策边界x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))Z_gbm = gbm.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)Z_lr = lr.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)plt.figure(figsize=(12, 6))plt.subplot(1, 2, 1)plt.contourf(xx, yy, Z_gbm, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Gradient Boosting Machine")plt.subplot(1, 2, 2)plt.contourf(xx, yy, Z_lr, alpha=0.4)plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')plt.title("Logistic Regression")plt.show()# 输出模型的准确率print("Gradient Boosting Machine Accuracy:", accuracy_score(y_test, gbm.predict(X_test)))print("Logistic Regression Accuracy:", accuracy_score(y_test, lr.predict(X_test)))
比较了梯度提升机模型和逻辑回归模型在相同数据集上的表现，并绘制了梯度提升机模型的决策边界和逻辑回归模型的决策边界，体现了梯度提升机模型在处理复杂分类问题方面的优势。