Artificial Intelligence With Python 简明教程

AI with Python – Supervised Learning: Classification

在本教程中，我们将重点介绍实施监督学习-分类。

分类技术或模型尝试从观测值中获取某些结论。在分类问题中，我们有分类输出，例如“黑色”或“白色”、“教学”和“非教学”。在构建分类模型时，我们需要有包含数据点和对应标签的训练数据集。例如，如果我们想检查该图像是否是汽车的图像。为了检查这一点，我们将构建一个具有与“汽车”和“非汽车”相关的两个类的训练数据集。然后我们需要使用训练样本来训练模型。分类模型主要用于人脸识别、垃圾邮件识别等。

Steps for Building a Classifier in Python

为了在 Python 中构建分类器，我们将使用 Python 3 和 Scikit-learn（一种机器学习工具）。按照以下步骤在 Python 中构建分类器 −

Step 1 − Import Scikit-learn

这是在 Python 中构建分类器的第一步。在此步骤中，我们将安装一个名为 Scikit-learn 的 Python 包，它是 Python 中最好的机器学习模块之一。以下命令将有助于我们导入包 −

Import Sklearn

Step 2 − Import Scikit-learn’s dataset

在此步骤中，我们可以开始针对机器学习模型处理数据集。此处，我们将使用乳腺癌威斯康星诊断数据库。该数据集包括有关乳腺癌肿瘤的各种信息，以及 malignant 或 benign 分类标签。该数据集具有 569 个实例，或数据，针对 569 个肿瘤，并且包括有关 30 个属性，或特征，的信息，例如肿瘤的半径、纹理、光滑度和面积。借助以下命令，我们可以导入 Scikit-learn 的乳腺癌数据集 −

from sklearn.datasets import load_breast_cancer

现在，以下命令将加载数据集。

data = load_breast_cancer()

以下是重要字典键的列表 −

Classification label names(target_names)
The actual labels(target)
The attribute/feature names(feature_names)
The attribute (data)

现在，借助以下命令，我们可以为每个重要信息集创建新变量并分配数据。换句话说，我们可以使用以下命令来组织数据 −

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

现在，为了更清楚，我们可以借助以下命令来打印类标签、第一个数据实例的标签、我们的特征名称和特征值 −

print(label_names)

上述命令将打印分别为恶性和良性的类名称。如下所示显示为输出 −

['malignant' 'benign']

现在，以下命令将显示它们映射到二进制值 0 和 1。此处 0 表示恶性癌症，1 表示良性癌症。您将收到以下输出 −

print(labels[0])
0

下面给出的两个命令将生成特征名称和特征值。

print(feature_names[0])
mean radius
print(features[0])
[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

从上述输出，我们可以看到第一个数据实例是一个半径为 1.7990000e+01 的恶性肿瘤。

Step 3 − Organizing data into sets

在此步骤中，我们将把数据分成两部分，即训练集和测试集。将数据分成这些集合非常重要，因为我们必须在未见数据上测试我们的模型。为了将数据分成集合，sklearn 有一个名为 train_test_split() 的函数。借助以下命令，我们可以将数据分成这些集合 −

from sklearn.model_selection import train_test_split

上述命令将从 sklearn 导入 train_test_split 函数，下面的命令将把数据分成训练数据和测试数据。在下面给出的示例中，我们使用 40% 的数据进行测试，剩余数据将用于训练模型。

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

Step 4 − Building the model

在此步骤中，我们将构建我们的模型。我们将使用朴素贝叶斯算法来构建模型。可以使用以下命令来构建模型 −

from sklearn.naive_bayes import GaussianNB

上述命令将导入 GaussianNB 模块。现在，以下命令将帮助您初始化模型。

gnb = GaussianNB()

我们将通过使用 gnb.fit() 将模型拟合到数据来训练模型。

model = gnb.fit(train, train_labels)

Step 5 − Evaluating the model and its accuracy

在此步骤中，我们将通过对我们的测试数据进行预测来评估模型。然后我们将找出其准确性。为了进行预测，我们将使用 predict() 函数。以下命令将帮助您执行此操作 −

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 的系列是针对肿瘤类别（恶性和良性）的预测值。

现在，通过比较 test_labels 和 preds 这两个数组，我们可以找出模型的准确性。我们将使用 accuracy_score() 函数来确定准确性。请考虑以下命令 −

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

结果显示 NaiveBayes 分类器的准确率为 95.17%。

通过这种方式，借助以上步骤，我们可以在 Python 中构建分类器。

Building Classifier in Python

在本节中，我们将了解如何使用 Python 构建分类器。

Naïve Bayes Classifier

朴素贝叶斯是一种利用贝叶斯定理构建分类器的分类技术。假设预测变量是独立的。用简单的话来说，它假设某个特征在某个类别中出现与其他任何特征出现无关。要构建朴素贝叶斯分类器，我们需要使用名为 scikit learn 的 Python 库。scikit learn 包中有三种类型的朴素贝叶斯模型，即 Gaussian, Multinomial and Bernoulli 。

要构建朴素贝叶斯机器学习分类器模型，我们需要以下内容：

Dataset

我们将使用名为 Wisconsin 乳腺癌诊断数据库的数据集。该数据集包括乳腺癌肿瘤的各种信息，以及 malignant 或 benign 的分类标签。该数据集有 569 个实例或数据，涉及 569 个肿瘤，还包括 30 个属性或特征的信息，例如肿瘤的半径、质地、光滑度和面积。我们可以从 sklearn 包中导入这个数据集。

Naïve Bayes Model

要构建朴素贝叶斯分类器，我们需要一个朴素贝叶斯模型。如前所述，scikit learn 包中有三种类型的朴素贝叶斯模型，即 Gaussian, Multinomial 和 Bernoulli 。此处，在以下示例中，我们将使用高斯朴素贝叶斯模型。

通过使用上述内容，我们将构建一个朴素贝叶斯机器学习模型，利用肿瘤信息来预测肿瘤是否为恶性或良性。

首先，我们需要安装 sklearn 模块。这可以通过以下命令来完成：

Import Sklearn

现在，我们需要导入名为 Wisconsin 乳腺癌诊断数据库的数据集。

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。此处 0 表示恶性癌症，而 1 表示良性癌症。它作为输出如下所示：

print(labels[0])
0

以下两个命令将生成特征名称和特征值。

print(feature_names[0])
mean radius
print(features[0])

[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

从上述输出中可以看到，第一个数据实例是一个恶性肿瘤，其主半径为 1.7990000e+01。

为了在未见数据上测试我们的模型，我们需要将数据分为训练数据和测试数据。这可以通过以下代码来完成：

from sklearn.model_selection import train_test_split

上述命令将从 sklearn 中导入 train_test_split 函数，而下面的命令将把数据分成训练数据和测试数据。在下面的示例中，我们将 40% 的数据用于测试，而其余数据将用于训练模型。

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

现在，我们使用以下命令构建模型：

from sklearn.naive_bayes import GaussianNB

上述命令将导入 GaussianNB 模块。现在，借助以下给出的命令，我们需要初始化模型。

gnb = GaussianNB()

我们将通过使用 gnb.fit() 使模型适应数据来训练模型。

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 的序列是肿瘤类的预测值，即恶性和良性。

现在，通过比较 test_labels 和 preds 两个数组，我们可以找出我们模型的准确性。我们将使用 accuracy_score() 函数来确定准确性。考虑以下命令 −

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

结果表明，NaïveBayes 分类器准确率为 95.17%。

这是基于朴素贝叶斯高斯模型的机器学习分类器。

Support Vector Machines (SVM)

基本上，支持向量机（SVM）是一种监督机器学习算法，可用于回归和分类。SVM 的主要概念是将每个数据项作为具有 n 维空间的点进行绘制，其中每个特征的值都是特定坐标的值。这里 n 将是我们拥有的特征。以下是理解 SVM 概念的简单图形表示 −

在上面的图表中，我们有两个特征。因此，我们首先需要在二维空间中绘制这两个变量，其中每个点有两个坐标，称为支持向量。该线将数据分成两个不同的分类组。这条线将是分类器。

在这里，我们将使用 scikit-learn 和 iris 数据集构建一个 SVM 分类器。Scikitlearn 库包含 sklearn.svm 模块并提供 sklearn.svm.svc 进行分类。下面显示了基于 4 个特征预测虹膜植物类别的 SVM 分类器。

Dataset

我们将使用 iris 数据集，其中包含 3 类，每类有 50 个实例，其中每个类指代一种虹膜植物。每个实例有四个特征，即萼片长度、萼片宽度、花瓣长度和花瓣宽度。下面显示了基于 4 个特征预测虹膜植物类别的 SVM 分类器。

Kernel

这是 SVM 使用的技术。基本上这些是函数，它们采用低维输入空间并将其转换为更高维空间。它将不可分离问题转换为可分离问题。核函数可以在线性、多项式、rbf 和 sigmoid 中任意选择。在此示例中，我们将使用线性核。

现在让我们导入以下包 −

import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt

现在，加载输入数据 −

iris = datasets.load_iris()

我们采用前两个特征 −

X = iris.data[:, :2]
y = iris.target

我们将使用原始数据绘制支持向量机边界。我们正在创建一个网格进行绘制。

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]

我们需要给出正则化参数的值。

C = 1.0

我们需要创建 SVM 分类器对象。

Svc_classifier = svm_classifier.SVC(kernel='linear',
C=C, decision_function_shape = 'ovr').fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize = (15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap = plt.cm.tab10, alpha = 0.3)
plt.scatter(X[:, 0], X[:, 1], c = y, cmap = plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('SVC with linear kernel')

Logistic Regression

基本上，逻辑回归模型是监督分类算法家族成员之一。逻辑回归通过使用逻辑函数估计概率来衡量因变量和自变量之间的关系。

在这里，如果我们谈论因变量和自变量，那么因变量是我们将要预测的目标类变量，而自变量是我们将用于预测目标类的特征。

在逻辑回归中，估计概率意味着预测事件发生的可能性。例如，商店老板想预测进入商店的顾客是否会购买游戏机（例如）。顾客会有许多特征 - 性别、年龄等，商店老板将观察这些特征以预测发生的可能性，即购买游戏机与否。逻辑函数是用于使用各种参数构建函数的 S 型曲线。

Prerequisites

在使用逻辑回归来构建分类器之前，我们需要在我们的系统上安装 Tkinter 包。它可以从 https://docs.python.org/2/library/tkinter.html 安装。

现在，借助下方给定的代码，我们可以使用逻辑回归来创建分类器 −

首先，我们将导入一些包 −

import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt

现在，我们需要定义示例数据，具体如下 −

X = np.array([[2, 4.8], [2.9, 4.7], [2.5, 5], [3.2, 5.5], [6, 5], [7.6, 4],
              [3.2, 0.9], [2.9, 1.9],[2.4, 3.5], [0.5, 3.4], [1, 4], [0.9, 5.9]])
y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3])

接下来，我们需要创建逻辑回归分类器，具体如下 −

Classifier_LR = linear_model.LogisticRegression(solver = 'liblinear', C = 75)

很重要的一点是，我们需要训练这个分类器 −

Classifier_LR.fit(X, y)

现在，如何可视化输出？我们可以创建一个名为 Logistic_visualize() 的函数 −

Def Logistic_visualize(Classifier_LR, X, y):
   min_x, max_x = X[:, 0].min() - 1.0, X[:, 0].max() + 1.0
   min_y, max_y = X[:, 1].min() - 1.0, X[:, 1].max() + 1.0

在上文中，我们定义了在网格中使用的最小值和最大值 X 和 Y。此外，我们将定义绘制网格的步长。

mesh_step_size = 0.02

让我们按照以下方式定义 X 和 Y 值的网格 −

x_vals, y_vals = np.meshgrid(np.arange(min_x, max_x, mesh_step_size),
                 np.arange(min_y, max_y, mesh_step_size))

借助以下代码，我们可以在网格上运行分类器 −

output = classifier.predict(np.c_[x_vals.ravel(), y_vals.ravel()])
output = output.reshape(x_vals.shape)
plt.figure()
plt.pcolormesh(x_vals, y_vals, output, cmap = plt.cm.gray)

plt.scatter(X[:, 0], X[:, 1], c = y, s = 75, edgecolors = 'black',
linewidth=1, cmap = plt.cm.Paired)

以下代码行将指定绘图的边界

plt.xlim(x_vals.min(), x_vals.max())
plt.ylim(y_vals.min(), y_vals.max())
plt.xticks((np.arange(int(X[:, 0].min() - 1), int(X[:, 0].max() + 1), 1.0)))
plt.yticks((np.arange(int(X[:, 1].min() - 1), int(X[:, 1].max() + 1), 1.0)))
plt.show()

现在，在运行代码后，我们将得到以下输出，逻辑回归分类器 −

Decision Tree Classifier

决策树本质上是一个二叉树流程图，其中每个节点根据某些特征变量拆分一组观察结果。

在此，我们正在构建一个决策树分类器来预测男性或女性。我们将采用一个非常小的数据集，该数据集包含 19 个样本。这些样本将包含两个特征——“高度”和“头发长度”。

Prerequisite

为了构建以下分类器，我们需要安装 pydotplus 和 graphviz 。graphviz 是一个使用点文件绘制图形的工具， pydotplus 是 Graphviz 的 Dot 语言模块。它可以使用包管理器或 pip 安装。

现在，我们可以借助以下 Python 代码来构建决策树分类器 −

首先，让我们导入一些重要的库，如下所示 −

import pydotplus
from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.metrics import classification_report
from sklearn import cross_validation
import collections

现在，我们需要提供数据集，如下所示 −

X = [[165,19],[175,32],[136,35],[174,65],[141,28],[176,15],[131,32],
[166,6],[128,32],[179,10],[136,34],[186,2],[126,25],[176,28],[112,38],
[169,9],[171,36],[116,25],[196,25]]

Y = ['Man','Woman','Woman','Man','Woman','Man','Woman','Man','Woman',
'Man','Woman','Man','Woman','Woman','Woman','Man','Woman','Woman','Man']
data_feature_names = ['height','length of hair']

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split
(X, Y, test_size=0.40, random_state=5)

在提供数据集之后，我们需要拟合模型，具体如下 −

clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,Y)

使用以下 Python 代码可以进行预测：

prediction = clf.predict([[133,37]])
print(prediction)

我们可以借助以下 Python 代码形象化决策树：

dot_data = tree.export_graphviz(clf,feature_names = data_feature_names,
            out_file = None,filled = True,rounded = True)
graph = pydotplus.graph_from_dot_data(dot_data)
colors = ('orange', 'yellow')
edges = collections.defaultdict(list)

for edge in graph.get_edge_list():
edges[edge.get_source()].append(int(edge.get_destination()))

for edge in edges: edges[edge].sort()

for i in range(2):dest = graph.get_node(str(edges[edge][i]))[0]
dest.set_fillcolor(colors[i])
graph.write_png('Decisiontree16.png')

它将针对上述代码给出 [‘Woman’] 的预测并创建以下决策树：

我们可以更改预测中的特征值以对其进行测试。

Random Forest Classifier

我们知道，集成方法是将机器学习模型组合成更强大的机器学习模型的方法。随机森林（由决策树集合构成）便是其中之一。它优于单一决策树，因为它在保留预测能力的同时，可以通过对结果进行加权平均来减少过度拟合。此处，我们将在 scikit learn 癌症数据集上实现随机森林模型。

导入必需的包：

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
import matplotlib.pyplot as plt
import numpy as np

现在，我们需要提供数据集，具体做法如下：

cancer = load_breast_cancer()
X_train, X_test, y_train,
y_test = train_test_split(cancer.data, cancer.target, random_state = 0)

在提供数据集之后，我们需要拟合模型，具体如下 −

forest = RandomForestClassifier(n_estimators = 50, random_state = 0)
forest.fit(X_train,y_train)

现在，获得训练和测试子集的准确性：如果我们增加估计器的数量，则测试子集的准确性也会提高。

print('Accuracy on the training subset:(:.3f)',format(forest.score(X_train,y_train)))
print('Accuracy on the training subset:(:.3f)',format(forest.score(X_test,y_test)))

Output

Accuracy on the training subset:(:.3f) 1.0
Accuracy on the training subset:(:.3f) 0.965034965034965

现在，与决策树类似，随机森林具有 feature_importance 模块，它将提供比决策树更好的特征权重视图。可以将其绘制和形象化如下所示：

n_features = cancer.data.shape[1]
plt.barh(range(n_features),forest.feature_importances_, align='center')
plt.yticks(np.arange(n_features),cancer.feature_names)
plt.xlabel('Feature Importance')
plt.ylabel('Feature')
plt.show()

Performance of a classifier

在实现机器学习算法后，我们需要找出该模型的有效程度。度量有效性的标准可能基于数据集和指标。为了评估不同的机器学习算法，我们可以使用不同的性能指标。例如，假设使用分类器来区分不同对象的图像，则可以使用分类性能指标，如平均准确性、AUC 等。在一个或另一个意义上，我们选择来评估机器学习模型的指标非常重要，因为指标的选择影响了机器学习算法性能的度量和比较方式。以下是其中一些指标：

Confusion Matrix

它主要用于输出可以为两类或更多类别的分类问题。这是衡量分类器性能的最简单方法。混淆矩阵基本上是一个具有两个维度“实际”和“预测”的表格。这两个维度都具有“真阳性 (TP)”、“真阴性 (TN)”、“假阳性 (FP)”、“假阴性 (FN)”。

在上面的混淆矩阵中，1 表示阳性类别，0 表示阴性类别。

以下术语与混淆矩阵相关：

True Positives − TP 为数据点的实际类别为 1 且预测也是 1 的情况。
True Negatives − TN 为数据点的实际类别为 0 且预测也是 0 的情况。
False Positives − FP 为数据点的实际类别为 0 且预测也是 1 的情况。
False Negatives − FN 为数据点的实际类别为 1 且预测也是 0 的情况。

Accuracy

混淆矩阵本身不是性能度量，但几乎所有性能矩阵都基于混淆矩阵。其中之一是准确性。在分类问题中，可以将其定义为模型做出的正确预测在所有做出的预测中的数量。计算准确性的公式如下：

准确性 = \frac{TP+TN}{TP+FP+FN+TN}

Precision

它主要用于文档检索。它可以定义为有多少已返回的文档是正确的。下面是计算精度的公式 -

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

Recall or Sensitivity

它可以定义为模型返回了多少个正样本。下面是计算模型召回率/敏感性的公式 -

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

Specificity

它可以定义为模型返回了多少个负样本。它与召回率正好相反。下面是计算模型特异性的公式 -

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

Class Imbalance Problem

类不平衡是指属于一类的观测值数量显著低于属于其他类的观测值数量的情况。例如，这个问题在我们需要识别罕见疾病、银行的欺诈交易等情况下尤为突出。

Example of imbalanced classes

让我们考虑一个欺诈检测数据集的例子来理解不平衡类的概念 -

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Solution

Balancing the classes’ 是解决不平衡类的方法。平衡类的主要目的是增加少数类的频率或减少多数类的频率。以下是在解决不平衡类问题的方法 -

Re-Sampling

再抽样是一系列用于重建样本数据集的方法——包括训练集和测试集。执行再抽样是为了提高模型的准确性。下面是一些再抽样技术 -

Random Under-Sampling - 该技术旨在通过随机消除多数类的示例来平衡类分布。这样做直到多数类和少数类的实例平衡为止。

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

在这种情况下，我们从非欺诈实例中无放回地抽取 10% 的样本，然后将它们与欺诈性实例组合 -

无欺诈后的观测值随机降采样 = 4950 的 10% = 495

与欺诈性观测值合并后的总观测值 = 50 + 495 = 545

因此，现在，降采样后的新数据集的事件率为 9%

该技术的最大优点是它可以减少运行时间并改善存储。但另一方面，它在减少训练数据样本数量时会丢弃有用的信息。

Random Over-Sampling - 该技术旨在通过复制少数类中的实例来增加少数类的数量，从而平衡类分布。

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

如果我们将 50 个欺诈性观测值复制 30 次，则在复制少数类观测值之后，欺诈性观测值将为 1500。然后，对新数据过采样后的总观测值为 4950 + 1500 = 6450。因此，新数据集的事件率为 1500/6450 = 23%。

该方法的主要优点是没有丢失有用的信息。但另一方面，它因为复制了少数类事件导致过拟合的可能性增加。

Ensemble Techniques

这种方法主要用于修改现有的分类算法，使它们适用于不平衡的数据集。在这种方法中，我们从原始数据构建几个两阶段分类器，然后汇总它们的预测。随机森林分类器是基于集合的分类器的示例。