幂简集成LOGO
API Hub
找服务商
API知识库
我是服务商
产品和服务
关于我们
控制台
所有文章 > AI驱动 > 彻底搞懂分类预测算法！
彻底搞懂分类预测算法！

彻底搞懂分类预测算法！

2025-01-03

决策树分类算法

一句话概括

决策树通过一系列的规则（if-else）来对数据进行分类，每个节点代表一个特征，每个分支代表一个规则，最终到达叶节点得到分类结果。

算法原理训练过程

  1. 选择最优特征：在训练数据集上，通过计算每个特征的信息增益（或基尼指数、熵等）来选择最优特征。
  2. 划分数据集：根据选定的特征，将数据集划分为两个子集。
  3. 递归：对每个子集重复上述步骤，直到满足停止条件（如达到最大深度、叶节点数量等）。
  4. 创建叶节点：当满足停止条件时，创建叶节点，并赋予该节点的类别。

核心公式

信息增益（对于特征A）：

优缺点

优点

  • 易于理解：决策树的结构直观，易于理解和解释。
  • 处理混合数据：可以处理数值型和类别型数据。

缺点

  • 过拟合：容易在训练数据上过拟合，导致泛化能力差。
  • 计算量大：构建树的过程中计算量较大，尤其是数据量较大时。

调优经验

  • 剪枝：通过限制树的深度、设置最小叶节点数量等方式来减少过拟合。
  • 交叉验证：使用交叉验证来选择最优的剪枝参数。
  • 特征选择：选择与目标变量相关性高的特征。

Python简单示例代码

from sklearn.datasets import load_iris

from sklearn.tree import DecisionTreeClassifier

from sklearn.model_selection import train_test_split



# 加载数据

data = load_iris()

X = data.data

y = data.target



# 划分训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)



# 创建决策树分类器

clf = DecisionTreeClassifier()



# 训练模型

clf.fit(X_train, y_train)



# 预测测试集

y_pred = clf.predict(X_test)



# 评估模型

print("Accuracy:", clf.score(X_test, y_test))

以上代码展示了如何使用Python的scikit-learn库来训练和使用决策树分类器。

分类算法：支持向量机（SVM）

一句话通俗概括原理

SVM通过找到一个最优的超平面来将数据集划分为不同的类别，使得两类数据点之间的间隔最大。

算法原理及训练过程

算法原理

SVM的核心思想是找到一个最优的超平面，使得这个超平面可以将不同类别的数据点尽可能地分开，并且尽可能地将两类数据点之间的间隔最大化。

训练过程

  1. 选择一个合适的核函数，例如线性核、多项式核或径向基函数核。
  2. 使用最大间隔原理求解最优超平面，即找到最优的权重向量和偏置项。
  3. 对于线性可分的数据集，使用拉格朗日乘子法求解二次规划问题，得到最优解。
  4. 根据最优解计算支持向量，即超平面上距离最近的那些数据点。

核心公式

对于线性可分的数据集，SVM的目标函数为：

约束条件为：

其中，为第个数据点，为对应的标签，表示内积。

通过求解上述二次规划问题，可以得到最优解和。

优缺点

优点

  1. 在高维空间中表现良好。
  2. 可以处理非线性问题。
  3. 对噪声和异常值具有较好的鲁棒性。

缺点

  1. 训练过程计算复杂，时间复杂度高。
  2. 对于大规模数据集，训练过程可能变得非常耗时。
  3. 超参数的选择对模型性能有很大影响。

调优经验

  1. 选择合适的核函数。
  2. 使用交叉验证方法选择合适的超参数。
  3. 使用网格搜索或随机搜索等方法进行超参数调优。
  4. 考虑使用正则化项来防止过拟合。

Python简单示例代码

from sklearn import datasets

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.svm import SVC



# 加载数据集

iris = datasets.load_iris()

X = iris.data

y = iris.target



# 划分训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)



# 数据标准化

scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_test = scaler.transform(X_test)



# 创建SVM模型

model = SVC(kernel='linear', C=1.0)



# 训练模型

model.fit(X_train, y_train)



# 评估模型

score = model.score(X_test, y_test)

print(f'测试集准确率：{score:.2f}')

K近邻算法（KNN）详解

一句话通俗概括原理

K近邻算法是一种通过比较数据集中最近的K个邻居的标签来预测新数据点标签的简单监督学习方法。

算法原理及训练过程

原理

K近邻算法的核心思想是：相似性高的数据点通常具有相似的标签。在训练过程中，算法不进行数据的存储，而是直接在训练数据集上进行预测。

训练过程

  1. 收集数据，并将其分为特征集和标签集。
  2. 当有新数据点需要预测时，计算该数据点与训练数据集中所有数据点的距离。
  3. 选择距离最近的K个数据点，并统计这K个数据点的标签。
  4. 根据这K个邻居的多数标签来预测新数据点的标签。

核心公式

距离计算公式：

其中， 和  分别是第  个训练数据点和待预测数据点的特征向量， 和  是对应的标签。

优缺点

优点

  • 简单易懂，易于实现。
  • 对数据分布没有特定的要求，可以适用于各种数据类型。
  • 在数据量较大的情况下，算法性能较好。

缺点

  • 计算量大，时间复杂度高。
  • 对噪声数据敏感，容易受到异常值的影响。
  • 需要预先选择合适的K值。

调优经验

  • 选择合适的K值：K值过小可能导致过拟合，K值过大可能导致欠拟合。
  • 数据预处理：对数据进行标准化处理，以消除量纲的影响。
  • 特征选择：选择对分类有重要影响的特征，减少计算量。

Python简单示例代码

from collections import Counter

import numpy as np



def knn_predict(train_data, train_labels, test_data, k):

    distances = []

    for i in range(len(train_data)):

        dist = np.linalg.norm(test_data - train_data[i])

        distances.append((train_data[i], train_labels[i], dist))

    distances.sort(key=lambda x: x[2])

    k_nearest = distances[:k]

    label_counts = Counter([label for _, label, _ in k_nearest])

    return label_counts.most_common(1)[0][0]



# 示例数据

train_data = np.array([[1, 2], [2, 3], [3, 4], [5, 6], [7, 8]])

train_labels = [0, 0, 0, 1, 1]

test_data = np.array([6, 6])



# 预测

k = 3

prediction = knn_predict(train_data, train_labels, test_data, k)

print("预测结果：", prediction)

朴素贝叶斯分类算法简介

一句话通俗概括原理

朴素贝叶斯分类算法基于贝叶斯定理，通过计算每个类别条件下特征的概率，选择概率最大的类别作为预测结果。

算法原理及训练过程

核心公式

其中：

训练过程

优缺点

优点

  • 简单高效：算法原理简单，计算效率高。
  • 对缺失值不敏感：即使某些特征缺失，算法仍能进行分类。
  • 对异常值不敏感：异常值对条件概率的影响较小。

缺点

  • 假设特征独立性：朴素贝叶斯假设特征之间相互独立，这在实际应用中可能不成立。
  • 对连续特征的离散化：需要对连续特征进行离散化处理，可能会丢失信息。

调优经验

  • 特征选择：选择对分类任务影响较大的特征。
  • 特征预处理：对特征进行标准化或归一化处理。
  • 交叉验证：使用交叉验证方法选择最优的模型参数。

Python简单示例代码

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.naive_bayes import GaussianNB

from sklearn.metrics import accuracy_score



# 加载数据

iris = load_iris()

X = iris.data

y = iris.target



# 划分训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)



# 创建朴素贝叶斯模型

gnb = GaussianNB()



# 训练模型

gnb.fit(X_train, y_train)



# 预测结果

y_pred = gnb.predict(X_test)



# 计算准确率

accuracy = accuracy_score(y_test, y_pred)

print(f'Accuracy: {accuracy}')

以上代码展示了如何使用Python中的sklearn库实现朴素贝叶斯分类算法，包括数据加载、模型训练和预测。

分类算法：逻辑回归

一句话通俗概括原理

逻辑回归是一种用于二分类问题的统计方法，通过预测一个样本属于某个类别的概率来分类。

算法原理训练过程

  1. 训练过程：
    • 首先，通过最小化损失函数来训练模型。
    • 损失函数通常采用对数损失函数（Log Loss），它是实际预测概率与真实概率之间差异的度量。
    • 在迭代过程中，通过梯度下降算法来调整模型的参数，使得模型能够更好地预测样本的类别。
  2. 核心公式：

优缺点

  • 优点：
    • 简单易用，易于理解和实现。
    • 对数据没有太多要求，可以处理非线性问题。
  • 缺点：
    • 预测能力有限，对于复杂问题可能效果不佳。
    • 容易过拟合，需要使用正则化等方法来避免。

调优经验

  • 数据预处理：确保数据干净、完整，并进行适当的特征工程。
  • 正则化：使用L1或L2正则化来避免过拟合。
  • 学习率调整：选择合适的学习率，避免过快或过慢的收敛。
  • 交叉验证：使用交叉验证来评估模型的性能，避免过拟合。

Python简单示例代码

import numpy as np

from sklearn.linear_model import LogisticRegression



# 生成示例数据

X = np.array([[0, 0], [1, 0], [0, 1], [1, 1]])

y = np.array([0, 0, 0, 1])



# 创建逻辑回归模型

model = LogisticRegression()



# 训练模型

model.fit(X, y)



# 预测新样本

new_data = np.array([[1, 0]])

prediction = model.predict(new_data)



print("预测结果：", prediction)

以上是逻辑回归算法的详细介绍和Python示例代码。希望对您有所帮助！

分类算法神经网络简介

通俗概括原理

神经网络是一种模仿人脑工作原理的计算模型，通过调整连接权重来学习和识别数据中的特征，从而实现分类。

算法原理

神经网络由输入层、隐藏层和输出层组成。每个神经元接收前一层神经元的输出，通过激活函数进行处理，再传递给下一层。最终的输出层输出类别预测。

训练过程

  1. 初始化参数：设定连接权重和偏置项。
  2. 前向传播：将输入数据通过神经网络，计算输出。
  3. 计算损失：根据输出和真实标签计算损失函数。
  4. 反向传播：利用梯度下降算法，根据损失函数的梯度调整权重和偏置项。
  5. 迭代优化：重复前向传播和反向传播，直至满足停止条件（如损失函数收敛）。

核心公式

优缺点

优点：

  • 强大的特征学习能力。
  • 能够处理非线性问题。
  • 可解释性较好。

缺点：

  • 计算量大。
  • 对数据质量敏感。
  • 容易过拟合。

调优经验

  1. 选择合适的激活函数：如ReLU、Sigmoid等。
  2. 调整学习率：避免过快或过慢的收敛。
  3. 添加正则化项：如L1、L2正则化，防止过拟合。
  4. 数据预处理：如归一化、标准化等。

Python简单示例代码

import numpy as np



# 激活函数

def sigmoid(x):

    return 1 / (1 + np.exp(-x))



# 损失函数

def mse_loss(y_true, y_pred):

    return (y_true - y_pred) ** 2 / 2



# 梯度下降

def gradient_descent(X, y, theta, alpha, iterations):

    m = X.shape[0]

    for _ in range(iterations):

        y_pred = sigmoid(X @ theta)

        gradient = X.T @ (y_pred - y) / m

        theta -= alpha * gradient

    return theta



# 示例数据

X = np.array([[1, 2], [2, 3], [3, 4], [4, 5]])

y = np.array([0, 0, 1, 1])

theta = np.array([0.5, 0.5])



# 训练模型

alpha = 0.01

iterations = 10000

theta = gradient_descent(X, y, theta, alpha, iterations)



# 预测

y_pred = sigmoid(X @ theta)

print(y_pred)

以上是一个简单的神经网络分类算法的Python示例代码，其中包含了激活函数、损失函数和梯度下降的实现。

分类算法：随机森林

一句话通俗概括原理

随机森林是一种基于决策树的集成学习方法，它通过构建多棵决策树并综合它们的预测结果来进行分类。

算法原理与训练过程

随机森林算法的工作原理如下：

  1. 数据抽样：从原始数据集中随机抽取一部分数据作为训练集。
  2. 特征选择：从所有特征中随机选择一部分特征作为决策树的分裂依据。
  3. 构建决策树：使用训练集和选择的特征构建决策树。
  4. 重复步骤1-3：重复上述步骤，构建多棵决策树。
  5. 投票：对于每个样本，将多棵决策树的预测结果进行投票，选取得票数最多的类别作为最终预测结果。

核心公式

随机森林没有特定的核心公式，而是基于决策树算法的组合。

优缺点

优点

  • 鲁棒性强：对噪声数据和缺失值具有较好的鲁棒性。
  • 过拟合能力低：由于构建多棵决策树，可以降低过拟合的风险。
  • 易于实现：算法实现简单，易于理解和操作。

缺点

  • 计算复杂度高：构建多棵决策树需要大量的计算资源。
  • 特征数量限制：当特征数量较多时，算法的性能会下降。

调优经验

  • 样本数量和特征数量：增加样本数量和特征数量可以提高算法的性能。
  • 决策树数量：增加决策树数量可以提高预测精度，但也会增加计算复杂度。
  • 特征选择：选择与目标变量相关的特征可以提高预测精度。

Python简单示例代码

from sklearn.datasets import load_iris

from sklearn.ensemble import RandomForestClassifier

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score



# 加载数据集

iris = load_iris()

X = iris.data

y = iris.target



# 划分训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)



# 创建随机森林分类器

rf = RandomForestClassifier(n_estimators=100, random_state=42)



# 训练模型

rf.fit(X_train, y_train)



# 预测结果

y_pred = rf.predict(X_test)



# 计算准确率

accuracy = accuracy_score(y_test, y_pred)

print(f"Accuracy: {accuracy:.2f}")

以上代码展示了如何使用随机森林算法进行分类任务。

梯度提升机（GBM）算法介绍

一句话通俗概括原理

梯度提升机（GBM）是一种通过迭代最小化损失函数来构建预测模型的方法，它通过将多个弱学习器（如决策树）组合成强学习器，以提升预测准确性。

算法原理训练过程

  1. 初始化一个预测模型，通常是常数预测。
  2. 对于每个样本，计算损失函数的梯度，这代表了样本真实值与预测值之间的差距。
  3. 选择一个弱学习器（如决策树），使其学习到损失函数的梯度方向。
  4. 使用该弱学习器对数据进行拟合，并更新预测模型。
  5. 重复步骤2-4，直到达到预设的迭代次数或损失函数收敛。

核心公式

损失函数通常使用均方误差（MSE）：

优缺点

优点

  • 预测准确性高。
  • 对缺失值不敏感。
  • 能够处理非线性关系。

缺点

  • 训练时间较长。
  • 对超参数敏感，需要仔细调整。

调优经验

  • 选择合适的损失函数。
  • 选择合适的弱学习器（如决策树）和参数。
  • 使用交叉验证来选择最佳超参数。
  • 调整学习率和迭代次数。

Python简单示例代码

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split



# 加载数据

iris = load_iris()

X, y = iris.data, iris.target



# 划分训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)



# 创建GBM分类器

gbm = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3)



# 训练模型

gbm.fit(X_train, y_train)



# 测试模型

score = gbm.score(X_test, y_test)

print(f"Test score: {score}")

文章转自微信公众号@Python人工智能前沿

上一篇：

深入了解神经网络：定义、结构及其在深度学习中的应用

下一篇：

特征工程与数据处理全流程（Python）
#你可能也喜欢这些API文章!
搜索、试用、集成国内外API！
幂简集成API平台已有 4578种API!
API大全
同话题下的热门内容
na
最新LangChain+GLM4开发AI应用程序系列（一）：快速入门篇
2024-11-25
na
GraphRAG：基于PolarDB+通义千问api+LangChain的知识图谱定制实践
2024-11-21
na
基于自定义数据集的微调：Alpaca与LLaMA模型的训练
2024-11-20
na
如何运用AI提高自己的工作效率？
2024-11-16
na
掌握ChatGPT插件与自定义GPT
2024-10-29
na
释放创意潜能：AI3D模型生成服务EasyPeasy的集成指南
2024-10-08
内容目录
  1. 决策树分类算法
  2. 分类算法：支持向量机（SVM）
  3. K近邻算法（KNN）详解
  4. 朴素贝叶斯分类算法简介
  5. 分类算法：逻辑回归
  6. 分类算法神经网络简介
  7. 分类算法：随机森林
  8. 梯度提升机（GBM）算法介绍