Python语言· Python人工智能·Python 分类

全部教程

Python监督学习：分类

在本章中，我们将重点关注实施有监督的学习 - 分类。

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

在Python中构建分类器的步骤

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

第1步 - 导入Scikit-learn

这将是在Python中构建分类器的第一步。在这一步中，我们将安装一个名为Scikit-learn的Python包，它是Python中最好的机器学习模块之一。

以下命令将帮助我们导入包：

import Sklearn

第2步 - 导入Scikit-learn的数据集

在这一步中，我们可以开始使用我们的机器学习模型的数据集。在这里，我们将要使用乳腺癌诊断威斯康星数据库 : http://scikit-learn.org/stable/datasets/index.html#breast-cancer-wisconsin-diagnostic-database 该数据集包括关于乳腺癌肿瘤的各种信息，以及恶性或 良性的 分类标签。该数据集在569个肿瘤上具有569个实例或数据，并且包括关于30个属性或特征的信息，例如肿瘤的半径，纹理，平滑度和面积。

借助以下命令，我们可以导入Scikit-learn的乳腺癌数据集：

from sklearn.datasets import load_breast_cancer

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

data = load_breast_cancer()

以下是重要字典键列表：

分类标签名称（target_names）
实际标签（目标）
属性/功能名称（feature_names）
属性（数据）

现在，借助以下命令，我们可以为每个重要信息集创建新变量并分配数据。

换句话说，我们可以使用以下命令组织数据：

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。

第3步 - 将数据组织成集

在这一步中，我们将数据分为两部分，即训练集和测试集。将数据拆分成这些集非常重要，因为我们必须在看不见的数据上测试我们的模型。要将数据拆分成集合，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)

第4步 - 构建模型

在这一步中，我们将构建我们的模型。我们将使用NaïveBayes算法来构建模型。以下命令可用于构建模型：

from sklearn.naive_bayes import GaussianNB

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

gnb = GaussianNB()

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

model = gnb.fit(train, train_labels)

第5步 - 评估模型及其准确性

在此步骤中，我们将通过对测试数据进行预测来评估模型。然后我们也会发现它的准确性。为了进行预测，我们将使用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

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

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

在Python中构建分类器

在本节中，我们将学习如何在Python中构建分类器。

朴素贝叶斯分类器

NaïveBayes是一种分类技术，用于使用贝叶斯定理构建分类器。假设预测变量是独立的。简单来说，它假定类中特定特征的存在与任何其他特征的存在无关。为了构建NaïveBayes分类器，我们需要使用名为scikit learn的python库。在scikit学习包中有三种类型的NaïveBayes模型，名为 Gaussian，Multinomial和Bernoulli 。

要构建NaïveBayes机器学习分类器模型，我们需要以下和减去。

数据集

我们将使用名为Breast Cancer Wisconsin Diagnostic Database : http://scikit-learn.org/stable/datasets/index.html#breast-cancer-wisconsin-diagnostic-database 的数据集，该数据集包括关于乳腺癌肿瘤的各种信息，以及恶性或 良性的 分类标签。该数据集在569个肿瘤上具有569个实例或数据，并且包括关于30个属性或特征的信息，例如肿瘤的半径，纹理，平滑度和面积。我们可以从sklearn包导入这个数据集。

朴素贝叶斯模型

为了构建NaïveBayes分类器，我们需要一个NaïveBayes模型。如前所述，在scikit学习包中有三种类型的NaïveBayes模型，分别为 Gaussian，Multinomial 和 Bernoulli 。在这里，在下面的例子中，我们将使用GaussianNaïveBayes模型。

通过使用上述内容，我们将构建一个NaïveBayes机器学习模型，以使用肿瘤信息来预测肿瘤是恶性还是良性。

首先，我们需要安装sklearn模块。它可以在以下命令的帮助下完成

Import 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']

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

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％。

那是基于NaïveBayseGaussian模型的机器学习分类器。

支持向量机（SVM）

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

支持向量机2

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

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

数据集

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

核心

这是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')

svc与衬里内核

Logistic回归

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

在这里，如果我们讨论依赖变量和自变量，那么因变量是我们要预测的目标类变量，另一方面，自变量是我们将用于预测目标类的特征。

在逻辑回归中，估计概率意味着预测事件的可能发生。例如，店主想要预测进入商店的顾客将购买游戏站（例如）。将存在许多客户特征 - 性别，年龄等，商店管理员将观察到这些特征以预测可能性发生，即是否购买游戏站。逻辑函数是sigmoid曲线，用于构建具有各种参数的函数。

先决条件

在使用逻辑回归构建分类器之前，我们需要在我们的系统上安装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()

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

Logistic回归

决策树分类器

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

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

条件

要构建以下分类器，我们需要安装 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'] 并创建以下决策树：

deision_tree

我们可以更改预测中的要素值来测试它。

随机森林分类器

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

导入必要的包：

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)))

输出

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()

功能重要性

分类器的性能

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

混乱矩阵

基本上它用于分类问题，其中输出可以是两种或更多种类。这是衡量分类器性能的最简单方法。混淆矩阵基本上是具有两个维度的表，即“实际”和“预测”。这两个维度都具有“真阳性（TP）”，“真阴性（TN）”，“假阳性（FP）”，“假阴性（FN）”。

在上面的混淆矩阵中，1表示正类，0表示负类。

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

真阳性 - TP是实际的数据点类为1且预测值也为1的情况。
真负数 - TN是数据点的实际类为0且预测值也为0的情况。
误报 - FP是实际的数据点类为0且预测值也为1的情况。
假阴性 - FN是数据点的实际类为1且预测值也为0的情况。

准确性

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

混淆矩阵

精确

它主要用于文档检索。它可以定义为返回的文档中有多少是正确的。

以下是计算精度的公式：

混淆矩阵

召回或敏感

它可以定义为模型返回多少个正数。以下是计算模型召回/灵敏度的公式：

混淆矩阵

特异性

它可以定义为模型返回的负数有多少。这与召回完全相反。

以下是计算模型特异性的公式：

混淆矩阵

阶级失衡问题

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

不平衡类的示例

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

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

解

平衡类的 作用是解决不平衡的类。平衡阶级的主要目的是增加少数群体的频率或减少多数群体的频率。以下是解决不平衡类问题的方法。

重采样

重新采样是一系列用于重建样本数据集的方法 - 训练集和测试集。重新采样以提高模型的准确性。以下是一些重新采样技术：

随机欠采样 - 该技术旨在通过随机删除多数类示例来平衡类分布。这样做直到多数和少数类实例得到平衡。

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

在这种情况下，我们在没有替换非欺诈实例的情况下获取10％的样本，然后将它们与欺诈实例相结合 -

随机抽样后的非欺诈性观察= 4950的10％= 495

将它们与欺诈性观察结合后的总观察值= 50 + 495 = 545

因此，现在，采样后新数据集的事件率= 9％

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

随机过采样 - 该技术旨在通过复制少数类中的实例数来平衡类分布。

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

如果我们复制50次欺诈性观察30次，那么在复制少数类观测后的欺诈性观测将是1500次。然后在过采样后新数据中的总观测值将是4950 + 1500 = 6450.因此新数据集的事件率将是1500/6450 = 23％。

这种方法的主要优点是不会丢失有用的信息。但另一方面，它过度拟合的可能性增加，因为它复制了少数民族阶级的事件。

合奏技巧

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

合奏技巧

下一章：Python 监督学习：回归

Python监督学习：回归：回归是最重要的统计和机器学习工具之一。我们说机器学习之旅从回归开始就没有错。它可以被定义为允许我们基于数据做出决策的参数技术，或者换句话说，允许我们通过学习输入和输出变量之间的关系来基于数据进行预测。这里，依赖于 ...

上一章：Python 数据准备

下一章：Python 监督学习：回归