机器学习 - 分类算法

机器学习中的分类

分类可以定义为从观测值或给定数据点预测类别或类别的过程。分类输出可以具有“Black”或“White”或“spam”或“no spam”等形式。

机器学习中的分类是一种监督学习技术，其中算法使用标记数据进行训练，以预测新数据的类别。

从数学角度来看，分类是近似从输入变量（X）到输出变量（Y）的映射函数（f）的任务。它基本上属于监督机器学习，其中目标也与输入数据集一起提供。

分类问题的示例可以是电子邮件中的垃圾邮件检测。输出只有两个类别，“spam”和“no spam”；因此这是一个二元分类。

要实现这种分类，我们首先需要训练分类器。对于这个示例，将使用“spam”和“no spam”电子邮件作为训练数据。成功训练分类器后，它可以用于检测未知电子邮件。

分类中的学习器类型

针对分类问题，我们有两种类型的学习器 −

• Lazy Learners − 如名称所示，这种学习器在存储训练数据后等待测试数据出现。仅在获得测试数据后才进行分类。它们在训练上花费较少时间，但在预测上花费更多时间。Lazy Learners 的示例包括 K-nearest neighbor 和 case-based reasoning。
• Eager Learners − 与 Lazy Learners 相反，Eager Learners 在存储训练数据后无需等待测试数据出现即可构建分类模型。它们在训练上花费更多时间，但在预测上花费较少时间。Eager Learners 的示例包括 Decision Trees、Naive Bayes 和 Artificial Neural Networks (ANN)。

机器学习中的分类算法

分类算法是一种监督学习技术，它基于一组输入特征来预测分类目标变量。它常用于解决垃圾邮件检测、欺诈检测、图像识别、情感分析等问题。

分类模型的目标是学习输入特征（X）和目标变量（Y）之间的映射函数（f）。这个映射函数通常表示为决策边界，它将输入特征空间中的不同类别分开。一旦模型训练完成，它就可以用于预测新的、未见过的样本的类别。

以下是一些重要的机器学习分类算法 −

• Logistic Regression
• K-Nearest Neighbors (KNN)
• Support Vector Machine (SVM)
• Decision Tree
• Naive Bayes
• Random Forest

我们将在后续章节中详细讨论所有这些分类算法。不过，让我们先简要介绍这些算法如下 −

Logistic Regression

Logistic Regression 是一种流行的算法，用于二元分类问题，其中目标变量是具有两个类别的分类变量。它建模给定输入特征时目标变量的概率，并预测概率最高的类别。

Logistic Regression 是一种广义线性模型，其中目标变量遵循 Bernoulli 分布。该模型由输入特征的线性函数组成，该函数使用 logistic 函数进行转换，产生 0 到 1 之间的概率值。

K-Nearest Neighbors (KNN)

K-Nearest Neighbors (KNN) 是一种监督学习算法，可用于分类和回归问题。KNN 的主要思想是找到给定测试数据点的 k 个最近邻数据点，并使用这些最近邻进行预测。k 的值是一个需要调优的超参数，它表示要考虑的邻居数量。

对于分类问题，KNN 算法将测试数据点分配给 k 个最近邻中出现最频繁的类别。换句话说，邻居数量最多的类别就是预测类别。

对于回归问题，KNN 算法将测试数据点分配为 k 个最近邻值的平均值。

Support Vector Machine (SVM)

Support Vector Machines (SVMs) 是一种强大且灵活的监督机器学习算法，用于分类和回归。但通常，它们用于分类问题。SVMs 于 1960 年代首次引入，后来在 1990 年代得到了完善。与其他机器学习算法相比，SVMs 有其独特实现方式。如今，它们因能够处理多个连续和分类变量而极受欢迎。

Decision Tree

Decision Tree 算法是一种基于层次树的算法，用于根据一组规则对结果进行分类或预测。它通过根据输入特征的值将数据分割成子集来工作。算法递归地分割数据，直到每个子集中的数据属于同一类别或目标变量具有相同值为止。结果树是一组决策规则，可用于对新数据进行预测或分类。

Naive Bayes

Naive Bayes 算法是一种基于 Bayes 定理的分类算法。该算法假设特征之间相互独立，这就是为什么它被称为“naive”（朴素）。它根据样本特征的概率计算样本属于特定类别的概率。例如，如果一部手机具有触摸屏、互联网功能、良好相机等，则可视为智能手机。即使所有这些特征相互依赖，但这些特征独立地贡献于该手机是智能手机的概率。

Random Forest

Random Forest 是一种机器学习算法，它使用决策树集成来进行预测。该算法由 Leo Breiman 于 2001 年首次引入。其核心思想是创建大量决策树，每棵树都在数据的一个不同子集上训练。然后，将这些单个树的预测结果组合起来产生最终预测。

机器学习中分类的应用

分类算法的一些最重要的应用如下 −

• Speech Recognition
• Handwriting Recognition
• Biometric Identification
• Document Classification
• Image Classification
• Spam Filtering
• Fraud Detection
• Facial Recognition

机器学习中构建分类模型

现在让我们来看看构建分类模型所涉及的步骤 −

1. 数据准备

第一步是收集和预处理数据。这包括清理数据、处理缺失值，以及将分类变量转换为数值。

2. 特征提取/选择

下一步是从数据中提取或选择相关特征。这是一个重要步骤，因为特征的质量会极大地影响模型的性能。一些常见的特征选择技术包括相关性分析、特征重要性排名和主成分分析。

3. 模型选择

一旦选择了特征，下一步就是选择合适的分类算法。有许多不同的算法可供选择，每种算法都有其自身的优势和劣势。一些流行的算法包括 logistic regression、decision trees、random forests、support vector machines 和 neural networks。

4. 模型训练

选择合适的算法后，下一步是在标记的训练数据上训练模型。在训练过程中，模型学习输入特征与目标变量之间的映射函数。通过迭代调整模型参数，以最小化预测输出与实际输出之间的差异。

5. 模型评估

模型训练完成后，下一步是在独立的验证数据集上评估其性能。这是为了估计模型的准确性和泛化性能。常见的评估指标包括 accuracy、precision、recall、F1-score 和 receiver operating characteristic (ROC) 曲线下的面积。

5. 超参数调优

在许多情况下，通过调优模型的超参数可以进一步提升性能。超参数是在训练模型之前选择的设置，用于控制学习率、正则化强度以及 neural network 中的隐藏层数量等方面。Grid search、random search 和 Bayesian optimization 是一些常用的超参数调优技术。

6. 模型部署

模型训练和评估完成后，最后一步是在生产环境中部署模型。这包括将模型集成到更大的系统中、在真实世界数据上测试它，并随时间监控其性能。

使用 Python 构建分类模型

Scikit-learn 是一个用于 machine learning 的 Python 库，可以用于在 Python 中构建分类器。在 Python 中构建分类器的步骤如下 −

步骤 1：导入必要的 Python 包

使用 scikit-learn 构建分类器时，我们需要导入它。我们可以使用以下脚本导入 −

import sklearn

步骤 2：导入数据集

导入必要的包后，我们需要一个数据集来构建分类预测模型。我们可以从 sklearn datasets 导入它，或者根据需求使用其他数据集。我们将使用 sklearn 的 Breast Cancer Wisconsin Diagnostic Database。我们可以使用以下脚本导入它 −

from sklearn.datasets import load_breast_cancer

以下脚本将加载数据集；

data = load_breast_cancer()

我们还需要组织数据，这可以通过以下脚本完成 −

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

以下代码将打印标签名称，在我们的数据库中为 malignant 和 'benign'。

import sklearn
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

print(label_names)

上述命令的输出是标签名称 −

['malignant' 'benign']

这些标签映射到二进制值 0 和 1。Malignant 癌症由 0 表示，Benign 癌症由 1 表示。

这些标签的特征名称和特征值可以通过以下命令查看 −

print(feature_names[0])

上述命令的输出是标签 0（即 Malignant 癌症）的特征名称 −

mean radius

类似地，可以按以下方式生成标签的特征名称 −

print(feature_names[1])

上述命令的输出是标签 1（即 Benign 癌症）的特征名称 −

mean texture

我们可以使用以下命令打印这些标签的特征 −

print(features[0])

这将给出以下输出 −

[1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
 1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
 6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
 1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
 4.601e-01 1.189e-01]

我们可以使用以下命令打印这些标签的特征 −

print(features[1])

这将给出以下输出 −

[2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
7.017e-02  1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
5.225e-03  1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
2.341e+01  1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
2.750e-01  8.902e-02]

步骤 3：将数据组织成训练集和测试集

由于我们需要在未见过的数据上测试模型，我们将数据集分为两部分：训练集和测试集。我们可以使用 sklearn Python 包的 train_test_split() 函数将数据分割成集合。以下命令将导入该函数 −

from sklearn.model_selection import train_test_split

现在，下一个命令将数据分割成训练数据和测试数据。在本例中，我们使用 40% 的数据用于测试，60% 的数据用于训练 −

train, test, train_labels, test_labels = 
   train_test_split(features,labels,test_size = 0.40, random_state = 42)

步骤 4：模型评估

将数据分为训练和测试后，我们需要构建模型。我们将为此使用 Naive Bayes 算法。以下命令将导入 GaussianNB 模块 −

from sklearn.naive_bayes import GaussianNB

现在，按以下方式初始化模型 −

gnb = GaussianNB()

接下来，使用以下命令可以训练模型 −

model = gnb.fit(train, train_labels)

现在，为了评估目的，我们需要进行预测。这可以通过使用 predict() 函数来完成，如下所示 −

from sklearn.model_selection import train_test_split
train, test, train_labels, test_labels=train_test_split(features,labels,test_size = 0.40, random_state = 42)
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
model = gnb.fit(train, train_labels)
preds = gnb.predict(test)
print(preds)

这将给出以下输出 −

[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0
 1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0
 1 1 1 1 1 1 0 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0
 1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 1 0 0
 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 0
 0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1
 0 0 1 1 0 1]

输出中上述 0 和 1 系列是针对 Malignant 和 Benign 肿瘤类别的预测值。

步骤 5：计算准确率

我们可以通过比较两个数组 test_labels 和 preds 来找到前一步构建的模型的准确率。我们将使用 accuracy_score() 函数来确定准确率。

from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))

0.951754385965

上述输出显示 Naive Bayes 分类器的准确率为 95.17%。

分类模型的评估指标

即使你已经完成了 Machine Learning 应用程序或模型的实现，工作也并未结束。我们必须找出我们的模型有多有效？有不同的评估/性能指标，但我们必须仔细选择，因为指标的选择会影响机器学习算法性能的测量和比较方式。

以下是一些重要的分类评估指标，你可以根据你的数据集和问题类型从中选择 −

混淆矩阵

混淆矩阵是衡量分类问题性能的最简单方法，其中输出可以是两种或更多类型的类。混淆矩阵就是一个二维表格，维度分别是“实际”（Actual）和“预测”（Predicted），并且这两个维度都有“真正例 (TP)”、“真负例 (TN)”、“假正例 (FP)”、“假负例 (FN)”，如下所示 −

与混淆矩阵相关的术语解释如下 −

• True Positives (TP) − 当数据点的实际类别和预测类别均为 1 时的情况。
• True Negatives (TN) − 当数据点的实际类别和预测类别均为 0 时的情况。
• False Positives (FP) − 当数据点的实际类别为 0 而预测类别为 1 时的情况。
• False Negatives (FN) − 当数据点的实际类别为 1 而预测类别为 0 时的情况。

我们可以使用 sklearn 的 confusion_matrix() 函数来计算混淆矩阵。通过以下脚本，我们可以找到上述构建的二元分类器的混淆矩阵 −

from sklearn.metrics import confusion_matrix
preds = gnb.predict(test)
cm = confusion_matrix(test, preds)
print(cm)

输出

[
   [ 73   7]
   [  4 144]
]

准确率 (Accuracy)

准确率可以定义为我们的 ML 模型做出的正确预测数量。我们可以利用以下公式通过混淆矩阵轻松计算它 −

$$\mathrm{Accuracy=\frac{TP+TN}{TP+FP+FN+TN}}$$

对于上述构建的二元分类器，TP + TN = 73+144 = 217，TP+FP+FN+TN = 73+7+4+144=228。

因此，Accuracy = 217/228 = 0.951754385965，这与我们创建二元分类器后计算的结果相同。

精确率 (Precision)

精确率，用于文档检索，可以定义为我们的 ML 模型返回的正确文档数量。我们可以利用以下公式通过混淆矩阵轻松计算它 −

$$\mathrm{Precision=\frac{TP}{TP+FP}}$$

对于上述构建的二元分类器，TP = 73，TP+FP = 73+7 = 80。

因此，Precision = 73/80 = 0.915

召回率或敏感性 (Recall or Sensitivity)

召回率可以定义为我们的 ML 模型返回的正例数量。我们可以利用以下公式通过混淆矩阵轻松计算它 −

$$\mathrm{Recall=\frac{TP}{TP+FN}}$$

对于上述构建的二元分类器，TP = 73，TP+FN = 73+4 = 77。

因此，Recall = 73/77 = 0.94805

特异性 (Specificity)

特异性，与召回率相反，可以定义为我们的 ML 模型返回的负例数量。我们可以利用以下公式通过混淆矩阵轻松计算它 −

$$\mathrm{Specificity=\frac{TN}{TN+FP}}$$

对于上述构建的二元分类器，TN = 144，TN+FP = 144+7 = 151。

因此，Specificity = 144/151 = 0.95364

在后续章节中，我们将详细讨论机器学习中最流行的分类算法。