1. WIKI教程
2. 使用Python进行机器学习
3. 快速指南

快速指南

Machine Learning with Python - Introduction

Python是一个用于研究和开发生产系统的流行平台。 它是一种庞大的语言，具有许多模块，包和库，提供了多种实现任务的方法。

Python及其库如NumPy，SciPy，Scikit-Learn，Matplotlib用于数据科学和数据分析。 它们还广泛用于创建可扩展的机器学习算法。 Python实现了流行的机器学习技术，如分类，回归，推荐和聚类。

Python提供现成的框架，用于在较短的时间内有效地执行大量数据上的数据挖掘任务。 它包括通过线性回归，逻辑回归，NaïveBayes，k-means，K最近邻和随机森林等算法实现的几种实现。

Machine Learning with Python - Concepts

在本章中，您将详细了解Python在机器学习中的概念。

Python in Machine Learning

Python具有允许开发人员使用优化算法的库。 它实现了流行的机器学习技术，如推荐，分类和聚类。 因此，在进一步推进之前，有必要对机器学习进行简要介绍。

什么是机器学习？

数据科学，机器学习和人工智能是当今科技界的一些热门话题。 数据挖掘和贝叶斯分析是趋势，这增加了对机器学习的需求。 本教程是您进入机器学习世界的入口。

机器学习是一门处理系统编程的学科，以便使它们能够自动学习和改进经验。 在这里，学习意味着识别和理解输入数据并根据提供的数据做出明智的决定。 基于所有可能的输入来考虑所有决策是非常困难的。 为了解决这个问题，开发了一些算法，通过应用统计科学，概率，逻辑，数学优化，强化学习和控制理论的原理，从特定数据和过去的经验中建立知识。

机器学习算法的应用

开发的机器学习算法用于各种应用，例如 -

• 视觉处理
• 语言处理
• 预测股市趋势，天气等事情
• 模式识别
• Games
• 数据挖掘
• 专家系统
• Robotics

涉及机器学习的步骤

机器学习项目涉及以下步骤 -

• 定义问题
• 准备数据
• 评估算法
• 改善成果
• 提出结果

开始使用Python进行机器学习的最佳方法是端到端地完成项目，并涵盖关键步骤，如加载数据，汇总数据，评估算法和做出一些预测。 这为您提供了一种可复制的方法，可以在数据集之后使用数据集。 您还可以添加更多数据并改进结果。

Environment Setup

在本章中，您将学习如何在本地计算机上设置Python机器学习的工作环境。

库和包

要了解机器学习，您需要具备Python编程的基本知识。 此外，还有许多库和包通常用于执行下面列出的各种机器学习任务 -

• numpy - 用于其N维数组对象

• pandas - 是一个包含数据帧的数据分析库

• matplotlib - 用于创建图形和图形的2D绘图库

• scikit-learn - 用于数据分析和数据挖掘任务的算法

• seaborn - 基于matplotlib的数据可视化库

安装 (Installation)

您可以使用此处讨论的两种方法中的任何一种安装机器学习软件 -

Method 1

在各种操作系统上从python.org单独下载并安装Python，如下所述 -

要在下载后安装Python，请双击.exe （对于Windows）或.pkg （对于Mac）文件，然后按照屏幕上的说明进行操作。

对于Linux OS，请在提示符处使用以下命令检查是否已安装Python -

$ python --version. ...

如果未安装Python 2.7或更高版本，请使用发行版的软件包管理器安装Python。 请注意，命令和包名称会有所不同。

关于Debian衍生品，如Ubuntu，你可以使用apt -

$ sudo apt-get install python3

现在，打开命令提示符并运行以下命令以验证Python是否已正确安装 -

$ python3 --version
Python 3.6.2

同样，我们可以使用像pip这样的安装程序单独下载和安装必要的库，如numpy，matplotlib等。 为此，您可以使用此处显示的命令 -

$pip install numpy
$pip install matplotlib
$pip install pandas
$pip install seaborn

Method 2

或者，要同时安装Python和其他科学计算和机器学习包，我们应该安装Anaconda发行版。 它是Linux，Windows和OSX的Python实现，包含各种机器学习包，如numpy，scikit-learn和matplotlib。 它还包括Jupyter Notebook ，一个交互式Python环境。 我们可以根据我们的要求安装Python 2.7或任何3.x版本。

要从Continuum Analytics下载免费的Anaconda Python发行版，您可以执行以下操作 -

访问Continuum Analytics的官方网站及其下载页面。 请注意，安装过程可能需要15-20分钟，因为安装程序包含Python，关联软件包，代码编辑器和其他一些文件。 根据您的操作系统，选择安装过程，如下所述 -

For Windows - 选择Anaconda for Windows部分，并使用Python 2.7或3.x查看列。 您可以发现安装程序有两个版本，一个用于32位Windows，另一个用于64位Windows。 选择相关的一个。

For Mac OS - 滚动到Anaconda for OS X section 。 使用Python 2.7或3.x查看该列。 请注意，此处只有一个版本的安装程序:64位版本。

For Linux OS - 我们选择“Anaconda for Linux”部分。 使用Python 2.7或3.x查看该列。

请注意，您必须确保Anaconda的Python发行版安装在单个目录中，并且不会影响系统上的其他Python安装（如果有）。

要使用图形和图表，我们需要这些Python库包 - matplotlib和seaborn 。

如果你使用的是Anaconda Python，你的系统已经安装了numpy，matplotlib，pandas，seaborn等。 我们启动Anaconda Navigator来访问Jupyter Note书或Python的Spyder IDE。

打开其中任何一个后，键入以下命令 -

import numpy
import matplotlib

现在，我们需要检查安装是否成功。 为此，请转到命令行并键入以下命令 -

$ python
Python 3.6.3 |Anaconda custom (32-bit)| (default, Oct 13 2017, 14:21:34)
[GCC 7.2.0] on linux

接下来，您可以导入所需的库并打印其版本，如下所示 -

>>>import numpy
>>>print numpy.__version__
1.14.2
>>> import matplotlib
>>> print (matplotlib.__version__)
2.1.2
>> import pandas
>>> print (pandas.__version__)
0.22.0
>>> import seaborn
>>> print (seaborn.__version__)
0.8.1

Types of Learning

Machine Learning (ML)是一种自动学习，很少或没有人为干预。 它涉及编程计算机，以便他们从可用的输入中学习。 机器学习的主要目的是探索和构建可以从先前数据中学习并对新输入数据进行预测的算法。

学习算法的input是训练数据，表示经验， output是任何专业知识，通常采用可执行任务的另一算法的形式。 机器学习系统的输入数据可以是数字，文本，音频，视觉或多媒体。 系统的相应输出数据可以是浮点数，例如，火箭的速度，表示类别或类别的整数，例如来自图像识别的鸽子或向日葵。

在本章中，我们将了解我们的程序将访问的培训数据，以及如何自动学习过程以及如何评估此类机器学习算法的成功和性能。

学习的概念

学习是将经验转化为专业知识或知识的过程。

根据学习数据的性质和学习者与环境之间的相互作用，学习可以大致分为三类，如下所述。

• 监督学习
• 无监督学习
• 半监督学习

同样，有四类机器学习算法，如下所示 -

• 监督学习算法
• 无监督学习算法
• 半监督学习算法
• 强化学习算法

然而，最常用的是supervised和unsupervised learning 。

监督学习

监督学习通常用于现实世界的应用，例如面部和语音识别，产品或电影推荐以及销售预测。 监督学习可以进一步分为两种类型 - Regression和Classification 。

Regression训练并预测连续值响应，例如预测房地产价格。

Classification试图找到合适的类别标签，例如分析正面/负面情绪，男性和女性，良性和恶性肿瘤，安全和不安全的贷款等。

在监督学习中，学习数据带有描述，标签，目标或期望的输出，目标是找到将输入映射到输出的一般规则。 这种学习数据称为labeled data 。 然后，学习的规则用于标记具有未知输出的新数据。

监督学习涉及建立基于labeled samples的机器学习模型。 例如，如果我们构建一个系统来根据各种特征（如大小，位置等）估算土地或房屋的价格，我们首先需要创建一个数据库并对其进行标记。 我们需要教授算法哪些特征对应于什么价格。 基于该数据，该算法将学习如何使用输入特征的值来计算房地产的价格。

监督学习涉及从可用的训练数据中学习功能。 这里，学习算法分析训练数据并产生可用于映射新示例的派生函数。 有许多supervised learning algorithms ，如Logistic回归，神经网络，支持向量机（SVM）和朴素贝叶斯分类器。

监督学习的常见examples包括将电子邮件分类为垃圾邮件和非垃圾邮件类别，基于其内容标记网页以及语音识别。

无监督学习

无监督学习用于检测异常，异常值，例如欺诈或有缺陷的设备，或用于对销售活动具有类似行为的客户进行分组。 这与监督学习相反。 这里没有标记数据。

当学习数据仅包含一些没有任何描述或标签的指示时，编码器或算法可以找到底层数据的结构，发现隐藏的模式，或确定如何描述数据。 这种学习数据称为unlabeled data 。

假设我们有许多数据点，我们希望将它们分成几组。 我们可能不完全知道分类的标准是什么。 因此，无监督学习算法试图以最佳方式将给定数据集分类为特定数量的组。

无监督学习算法是分析数据和识别模式和趋势的极其强大的工具。 它们最常用于将类似输入聚类到逻辑组中。 无监督学习算法包括Kmeans，随机森林，分层聚类等。

Semi-supervised Learning

如果某些学习样本被标记，但其他一些没有标记，则它是半监督学习。 它利用大量unlabeled data for training并使用少量labeled data for testing 。 半监督学习适用于获取完全标记的数据集昂贵而标记小子集更实用的情况。 例如，通常需要熟练的专家来标记某些遥感图像，并且需要大量的现场实验来在特定位置定位油，同时获取未标记的数据相对容易。

强化学习

这里学习数据给出反馈，以便系统调整到动态条件以实现某个目标。 系统根据反馈响应评估其性能并作出相应的反应。 最着名的例子包括自动驾驶汽车和国际象棋大师算法AlphaGo。

机器学习的目的

机器学习可以被视为人工智能或人工智能的一个分支，因为将经验转化为专业知识或检测复杂数据中的模式的能力是人类或动物智能的标志。

作为一门科学领域，机器学习与统计学，信息论，博弈论和优化等其他学科有着共同的概念。

作为信息技术的一个子领域，它的目标是对机器进行编程，以便他们学习。

然而，可以看出，机器学习的目的不是建立智能行为的自动复制，而是利用计算机的力量来补充和补充人类智能。 例如，机器学习程序可以扫描和处理大型数据库，检测超出人类感知范围的模式。

Data Preprocessing, Analysis & Visualization

在现实世界中，我们经常遇到大量原始数据，这些数据不适合机器学习算法。 我们需要在将原始数据输入各种机器学习算法之前对其进行预处理。 本章讨论在Python机器学习中预处理数据的各种技术。

数据预处理

在本节中，让我们了解如何在Python中预处理数据。

最初，在文本编辑器（如记事本）中打开扩展名为.py文件，例如prefoo.py文件。

然后，将以下代码添加到此文件中 -

import numpy as np
from sklearn import preprocessing
#We imported a couple of packages. Let's create some sample data and add the line to this file:
input_data = np.array([[3, -1.5, 3, -6.4], [0, 3, -1.3, 4.1], [1, 2.3, -2.9, -4.3]])

我们现在准备对这些数据进行操作。

预处理技术

可以使用此处讨论的几种技术对数据进行预处理 -

平均删除

它涉及从每个特征中删除均值，使其以零为中心。 平均移除有助于消除特征中的任何偏差。

您可以使用以下代码进行平均删除 -

data_standardized = preprocessing.scale(input_data)
print "\nMean = ", data_standardized.mean(axis = 0)
print "Std deviation = ", data_standardized.std(axis = 0)

现在在终端上运行以下命令 -

$ python prefoo.py

您可以观察以下输出 -

Mean = [ 5.55111512e-17 -3.70074342e-17 0.00000000e+00 -1.85037171e-17]
Std deviation = [1. 1. 1. 1.]

观察到在输出中，平均值几乎为0，标准偏差为1。

Scaling

数据点中每个要素的值可以在随机值之间变化。 因此，重要的是缩放它们以使其符合指定的规则。

您可以使用以下代码进行缩放 -

data_scaler = preprocessing.MinMaxScaler(feature_range = (0, 1))
data_scaled = data_scaler.fit_transform(input_data)
print "\nMin max scaled data = ", data_scaled

现在运行代码，您可以观察以下输出 -

Min max scaled data = [ [ 1. 0. 1. 0. ]
                        [ 0. 1. 0.27118644 1. ]
                        [ 0.33333333 0.84444444 0. 0.2 ]
]

请注意，所有值都已在给定范围之间缩放。

规范化(Normalization)

标准化涉及调整特征向量中的值，以便以共同的比例测量它们。 在这里，调整特征向量的值，使它们总和为1.我们将以下行添加到prefoo.py文件中 -

您可以使用以下代码进行规范化 -

data_normalized = preprocessing.normalize(input_data, norm  = 'l1')
print "\nL1 normalized data = ", data_normalized

现在运行代码，您可以观察以下输出 -

L1 normalized data = [  [ 0.21582734 -0.10791367 0.21582734 -0.46043165]
                        [ 0. 0.35714286 -0.1547619 0.48809524]
                        [ 0.0952381 0.21904762 -0.27619048 -0.40952381]
]

规范化用于确保数据点由于其特征的性质而不会得到提升。

二值化(Binarization)

二值化用于将数字特征向量转换为布尔向量。 您可以使用以下代码进行二值化 -

data_binarized = preprocessing.Binarizer(threshold=1.4).transform(input_data)
print "\nBinarized data =", data_binarized

现在运行代码，您可以观察以下输出 -

Binarized data = [[ 1. 0. 1. 0.]
                  [ 0. 1. 0. 1.]
                  [ 0. 1. 0. 0.]
                 ]

当我们具有数据的先验知识时，该技术是有用的。

一个热编码

可能需要处理很少且分散的数值，您可能不需要存储这些值。 在这种情况下，您可以使用One Hot Encoding技术。

如果不同值的数量是k ，则它将该特征变换为k-dimensional向量，其中只有一个值是1而所有其他值都是0 。

您可以将以下代码用于一个热编码 -

encoder = preprocessing.OneHotEncoder()
encoder.fit([  [0, 2, 1, 12], 
               [1, 3, 5, 3], 
               [2, 3, 2, 12], 
               [1, 2, 4, 3]
])
encoded_vector = encoder.transform([[2, 3, 5, 3]]).toarray()
print "\nEncoded vector =", encoded_vector

现在运行代码，您可以观察以下输出 -

Encoded vector = [[ 0. 0. 1. 0. 1. 0. 0. 0. 1. 1. 0.]]

在上面的示例中，让我们考虑每个特征向量中的第三个特征。 值为1,5,2和4。

这里有四个单独的值，这意味着单热编码向量的长度为4.如果我们要编码值5，它将是向量[0,1,0,0]。 此向量中只有一个值可以是1。 第二个元素是1，表示该值为5。

标签编码

在有监督的学习中，我们主要遇到各种各样的标签，可以是数字或单词的形式。 如果它们是数字，则它们可以由算法直接使用。 但是，很多时候，标签需要是可读的形式。 因此，训练数据通常用单词标记。

标签编码是指将单词标签更改为数字，以便算法可以理解如何处理它们。 让我们详细了解如何执行标签编码 -

创建一个新的Python文件，并导入预处理包 -

from sklearn import preprocessing
label_encoder = preprocessing.LabelEncoder()
input_classes = ['suzuki', 'ford', 'suzuki', 'toyota', 'ford', 'bmw']
label_encoder.fit(input_classes)
print "\nClass mapping:"
for i, item in enumerate(label_encoder.classes_):
print item, '-->', i

现在运行代码，您可以观察以下输出 -

Class mapping:
bmw --> 0
ford --> 1
suzuki --> 2
toyota --> 3

如上面的输出所示，单词已被改为0索引号。 现在，当我们处理一组标签时，我们可以将它们转换如下 -

labels = ['toyota', 'ford', 'suzuki']
encoded_labels = label_encoder.transform(labels)
print "\nLabels =", labels
print "Encoded labels =", list(encoded_labels)

现在运行代码，您可以观察以下输出 -

Labels = ['toyota', 'ford', 'suzuki']
Encoded labels = [3, 1, 2]

这比手动维护单词和数字之间的映射更有效。 您可以通过将数字转换回字标签来检查，如下面的代码所示 -

encoded_labels = [3, 2, 0, 2, 1]
decoded_labels = label_encoder.inverse_transform(encoded_labels)
print "\nEncoded labels =", encoded_labels
print "Decoded labels =", list(decoded_labels)

现在运行代码，您可以观察以下输出 -

Encoded labels = [3, 2, 0, 2, 1]
Decoded labels = ['toyota', 'suzuki', 'bmw', 'suzuki', 'ford']

从输出中，您可以观察到映射得到了完美保留。

数据分析

本节详细讨论Python机器学习中的数据分析 -

加载数据集

我们可以直接从UCI机器学习库加载数据。 请注意，我们在这里使用pandas来加载数据。 我们还将使用pandas来探索数据，包括描述性统计和数据可视化。 请注意以下代码，并注意我们在加载数据时指定每列的名称。

import pandas
data = ‘pima_indians.csv’
names = ['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', ‘Outcome’]
dataset = pandas.read_csv(data, names = names)

运行代码时，您可以观察到数据集已加载并准备好进行分析。 在这里，我们下载了pima_indians.csv文件并将其移动到我们的工作目录中，并使用本地文件名加载它。

总结数据集

总结数据可以通过以下方式完成，具体如下 -

• 检查数据集的尺寸
• 列出整个数据
• 查看所有属性的统计摘要
• 由类变量细分数据

数据集的维度

您可以使用以下命令检查数据包含shape属性的实例（行）和属性（列）的数量。

print(dataset.shape)

然后，对于我们讨论过的代码，我们可以看到769个实例和6个属性 -

(769, 6)

列出整个数据

您可以查看整个数据并了解其摘要 -

print(dataset.head(20))

此命令打印前20行数据，如图所示 -

Sno Pregnancies Glucose BloodPressure SkinThickness Insulin Outcome
1        6        148         72           35          0       1
2        1         85         66           29          0       0
3        8        183         64            0          0       1
4        1         89         66           23         94       0
5        0        137         40           35        168       1
6        5        116         74            0          0       0
7        3         78         50           32         88       1
8       10        115          0            0          0       0
9        2        197         70           45        543       1
10       8        125         96            0          0       1
11       4        110         92            0          0       0
12      10        168         74            0          0       1
13      10        139         80            0          0       0
14       1        189         60           23        846       1
15       5        166         72           19        175       1
16       7        100          0            0          0       1
17       0        118         84           47        230       1
18       7        107         74            0          0       1
19       1        103         30           38         83       0

查看统计摘要

您可以使用以下命令查看每个属性的统计摘要，其中包括count，unique，top和freq。

print(dataset.describe())

上面的命令为您提供以下输出，显示每个属性的统计摘要 -

         Pregnancies Glucose BloodPressur SkinThckns Insulin Outcome
count       769       769       769         769       769     769
unique       18       137        48          52       187       3
top           1       100        70           0         0       0
freq        135        17        57         227       374     500

按类变量细分数据

您还可以使用此处显示的命令查看属于每个结果的实例（行）数作为绝对计数 -

print(dataset.groupby('Outcome').size())

然后你可以看到实例的结果数量 - 如图所示 -

Outcome
0         500
1         268
Outcome     1
dtype: int64

数据可视化

您可以使用两种类型的图形来显示数据，如图所示 -

• 单变量图来理解每个属性

• 多变量图可以理解属性之间的关系

单变量图

单变量图是每个变量的图。 考虑输入变量是数字的情况，我们需要创建每个输入变量的框和晶须图。 您可以使用以下代码来实现此目的。

import pandas
import matplotlib.pyplot as plt
data = 'iris_df.csv'
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']
dataset = pandas.read_csv(data, names=names)
dataset.plot(kind='box', subplots=True, layout=(2,2), sharex=False, sharey=False)
plt.show()

您可以更清楚地了解输出属性的分布，如下所示 -

盒子和晶须图

您可以使用下面显示的命令创建每个输入变量的直方图，以了解分布情况 -

#histograms
dataset.hist()
plt().show()

从输出中，您可以看到两个输入变量具有高斯分布。 因此，这些图有助于了解我们可以在程序中使用的算法。

多变量图

多变量图帮助我们理解变量之间的相互作用。

散点图矩阵

首先，让我们看一下所有属性对的散点图。 这有助于发现输入变量之间的结构化关系。

from pandas.plotting import scatter_matrix
scatter_matrix(dataset)
plt.show()

你可以观察输出如图所示 -

观察到在输出中存在一些属性对的对角分组。 这表明高度相关性和可预测的关系。

Training Data and Test Data

培训数据和测试数据是机器学习中的两个重要概念。 本章将详细讨论它们。

培训数据

训练集中的观察结果形成了算法用于学习的经验。 在监督学习问题中，每个观察包括观察到的输出变量和一个或多个观察到的输入变量。

测试数据

测试集是一组观察结果，用于使用某些性能指标评估模型的性能。 重要的是，测试集中不包括来自训练集的观察结果。 如果测试集确实包含来自训练集的示例，则难以评估算法是否已经学会从训练集中推广或者仅仅记住它。

概括良好的程序将能够有效地执行具有新数据的任务。 相反，通过学习过于复杂的模型来记忆训练数据的程序可以准确地预测训练集的响应变量的值，但是不能预测新示例的响应变量的值。 记忆训练集称为over-fitting 。 记住其观测结果的程序可能无法很好地执行其任务，因为它可以记忆噪声或巧合的关系和结构。 平衡记忆和概括，或过度拟合和不合适，是许多机器学习算法常见的问题。 Regularization可以应用于许多模型以减少过度拟合。

除了训练和测试数据之外，有时还需要第三组观察，称为validation或hold-out set 。 验证集用于调整称为hyper parameters变量，这些变量控制模型的学习方式。 该程序仍在测试集上进行评估，以估计其在现实世界中的表现; 由于程序已经专门针对验证数据进行了调整，因此不应将其在验证集上的性能用作模型实际性能的估计值。 将一组监督观察分为训练，验证和测试集是很常见的。 对分区的大小没有要求，它们可能根据可用数据量而有所不同。 通常将50％或更多的数据分配给训练集，25％分配给测试集，其余部分分配给验证集。

一些训练集可能只包含几百个观测值; 其他可能包括数百万。 廉价存储，增加的网络连接，无处不在的传感器智能手机以及对隐私的态度转变，促成了大数据的当代状态，或者数百万或数十亿示例的训练集。

但是，机器学习算法也遵循“垃圾输入，垃圾输出”的格言。 通过阅读包含许多错误的大型，令人困惑的教科书来学习测试的学生可能不会比阅读简短但写得很好的教科书的学生得分更好。 类似地，在大量噪声，不相关或不正确标记的数据上训练的算法将不会比在更小代表现实世界中的问题的较小数据集上训练的算法执行得更好。

许多受监督的训练集是手动或通过半自动化过程准备的。 在某些领域，创建大量受监督数据的成本可能很高。 幸运的是，几个数据集与scikit-learn捆绑在一起，允许开发人员专注于模拟实验。

在开发期间，特别是在训练数据稀缺时，可以使用称为cross-validation的实践来训练和验证关于相同数据的算法。 在交叉验证中，训练数据被分区。 使用除一个分区之外的所有分区来训练该算法，并在剩余分区上进行测试。 然后将分区旋转几次，以便对所有数据进行训练和评估算法。

例如，考虑原始数据集被划分为五个相同大小的子集，标记为A到E.最初，模型在分区B到E上训练，并在分区A上测试。在下一次迭代中，模型在分区上训练A，C，D和E，并在分区B上进行测试。旋转分区，直到模型在所有分区上经过训练和测试。 与测试单个数据分区相比，交叉验证可以更准确地估计模型的性能。

绩效衡量 - 偏差和差异

许多指标可用于衡量程序是否正在学习如何更有效地执行其任务。 对于监督学习问题，许多性能指标测量预测错误的数量。

模型的预测误差有两个根本原因 - bias和variance 。 假设您有许多训练集，这些训练集都是唯一的，但同样代表了人口。 无论训练的训练集如何，具有高偏差的模型都会对输入产生类似的误差; 该模型偏倚了自己对训练数据中所展示的关系的真实关系的假设。 相反，具有高方差的模型将根据训练的训练集产生输入的不同误差。 具有高偏差的模型是不灵活的，但具有高方差的模型可能非常灵活，因此它可以对训练集中的噪声进行建模。 也就是说，具有高方差的模型过度拟合训练数据，而具有高偏差的模型不适合训练数据。

理想情况下，模型将具有低偏差和方差，但减少一个的努力将经常增加另一个。 这被称为bias-variance trade-off 。 我们可能不得不考虑本教程中介绍的几个模型的偏差 - 方差权衡。 无监督学习问题没有测量的错误信号; 相反，无监督学习问题的性能指标衡量数据中发现的结构的一些属性。 大多数性能指标只能针对特定类型的任务进行计算。

应使用表现在现实世界中制造错误的成本的绩效测量来评估机器学习系统。 虽然这看起来微不足道，但以下示例说明了一般性任务的性能度量的使用，但不适用于其特定应用。

准确性，精确度和召回率

考虑一种分类任务，其中机器学习系统观察肿瘤并且必须预测这些肿瘤是良性还是恶性。 Accuracy或正确分类的实例的比例是对程序性能的明显衡量。 虽然准确度确实衡量了该计划的表现，但它没有区分被归类为良性的恶性肿瘤和被归类为恶性的良性肿瘤。 在某些应用程序中，所有类型错误产生的成本可能相同。 然而，在这个问题中，未能识别恶性肿瘤比将良性肿瘤误分类为恶性肿瘤更严重。

我们可以测量每个可能的预测结果，以创建分类器性能的不同快照。 当系统正确地将肿瘤归类为恶性肿瘤时，该预测称为true positive 。 当系统错误地将良性肿瘤归类为恶性肿瘤时，预测是false positive 。 类似地， false negative是对肿瘤是良性的不正确预测，而true negative是对肿瘤是良性的正确预测。 这四个结果可用于计算分类性能的几种常用度量，如准确度，精度，召回等。

准确度用以下公式计算 -

ACC = (TP + TN)/(TP + TN + FP + FN)

其中，TP是真阳性的数量

TN是真阴性的数量

FP是误报的数量

FN是假阴性的数量。

Precision是预测为恶性的肿瘤的一部分，实际上是恶性的。 精度用以下公式计算 -

PREC = TP/(TP + FP)

Recall是系统鉴定的恶性肿瘤的一部分。 召回按以下公式计算 -

R = TP/(TP + FN)

在该示例中，精确度测量预测为恶性的肿瘤的实际上是恶性的部分。 召回测量检测到的真正恶性肿瘤的比例。 精确度和召回率测量结果可以表明，具有令人印象深刻的准确度的分类器实际上无法检测到大多数恶性肿瘤。 如果大多数肿瘤是良性的，即使是从不预测恶性肿瘤的分类器也可以具有高精度。 具有较低准确度和较高召回率的不同分类器可能更适合于该任务，因为它将检测更多的恶性肿瘤。 还可以使用许多其他用于分类的性能度量。

Machine Learning with Python - Techniques

本章详细讨论了机器学习中使用的每种技术。

分类(Classification)

分类是一种机器学习技术，它使用已知数据来确定如何将新数据分类为一组现有类别。

请考虑以下示例以了解分类技术 -

credit card company收到数以万计的新信用卡申请。 这些应用程序包含有关几个不同功能的信息，如年龄，地点，性别，年薪，信用记录等。此算法的任务是将卡申请人分类为具有良好信用记录，不良信用记录和那些人的类别。有一个混合的信用记录。

在a hospital ，急诊室有超过15个功能（年龄，血压，心脏病，疾病的严重程度等）进行分析，然后再决定是否必须将某位患者送入重症监护病房，因为这是一项代价高昂的建议。只有那些能够生存并负担得起费用的患者才能得到优先考虑。 这里的问题是根据可用的特征或参数将患者分类为高风险和低风险患者。

在对给定数据集进行分类时，分类器系统执行以下操作 -

• 最初，使用任何学习算法准备新的数据模型。

• 然后测试准备好的数据模型。

• 之后，此数据模型用于检查新数据并确定其类。

分类（也称为分类）是一种机器学习技术，它使用已知数据来确定如何将新数据分类为一组现有标签/类/类别。

在分类任务中，程序必须学习从一个或多个独立变量或输入变量预测从属变量或输出变量的离散值。 也就是说，程序必须预测新观察的最可能的类别，类别或标签。 分类的应用包括预测某一天是否下雨，或预测某公司的股价是涨还是跌，或者判断某物品是否属于体育或娱乐部分。

分类是监督学习的一种形式。 Gmail，雅虎等邮件服务提供商使用此技术将新邮件归类为垃圾邮件或非垃圾邮件。 分类算法通过分析将某些邮件标记为垃圾邮件的用户行为来训练自己。 根据该信息，分类器决定新邮件是应该进入收件箱还是进入垃圾邮件文件夹。

分类的应用

• 检测信用卡欺诈 - 分类方法用于预测信用卡欺诈。 使用先前欺诈的历史记录，分类器可以预测哪些未来交易可能变成欺诈。

• 电子邮件垃圾邮件 - 根据以前的垃圾邮件的功能，分类器确定是否应将新收到的电子邮件发送到垃圾邮件文件夹。

朴素贝叶斯分类器技术

分类技术包括Naive Bayes Classifier ，这是一种构造分类器的简单技术。 它不是一种训练这种分类器的算法，而是一组算法。 贝叶斯分类器构造模型以对问题实例进行分类。 这些分类是使用可用数据进行的。

朴素贝叶斯分类器的一个重要特征是它只需要少量的训练数据来估计分类所需的参数。 对于某些类型的模型，可以在监督学习环境中非常有效地训练朴素贝叶斯分类器。

尽管它的假设过于简单，但朴素的贝叶斯分类器在许多复杂的现实世界中都能有效地运作。 这些在spam filtering和document classification 。

回归(Regression)

在回归中，程序预测连续输出或响应变量的值。 回归问题的示例包括根据其描述预测新产品的销售额或工作的薪水。 与分类类似，回归问题需要有监督的学习。 在回归任务中，程序根据输入或解释变量预测连续输出或响应变量的值。

建议(Recommendation)

推荐是一种流行的方法，可根据用户信息（如购买历史记录，点击次数和评级）提供密切推荐。 Google和亚马逊使用此方法根据其过去操作的信息显示其用户的推荐商品列表。 有些recommender engines在后台工作以捕获用户行为并根据早期用户操作推荐所选项目。 Facebook还使用推荐方法来识别和推荐人并向其用户发送朋友建议。

推荐引擎是基于其过去的记录和行为来预测用户可能感兴趣的模型。 当这在电影的上下文中应用时，这成为电影推荐引擎。 我们通过预测用户如何评价它们来过滤电影数据库中的项目。 这有助于我们将用户与电影数据库中的正确内容相关联。 这种技术在两个方面很有用:如果我们有一个庞大的电影数据库，用户可能会或可能不会找到与他的选择相关的内容。 此外，通过推荐相关内容，我们可以增加消费并获得更多用户。

Netflix，亚马逊Prime和类似的电影租赁公司严重依赖推荐引擎来保持用户的参与。 推荐引擎通常使用协同过滤或基于内容的过滤来生成推荐列表。 两种类型之间的区别在于提取建议的方式。 协同过滤根据当前用户的过去行为以及其他用户给出的评级构建模型。 然后，此模型用于预测此用户可能感兴趣的内容。另一方面，基于内容的过滤使用项目本身的功能，以便向用户推荐更多项目。 项目之间的相似性是这里的主要动机。 协作过滤通常在这种推荐方法中使用得更多。

群集(Clustering)

相关观察组称为聚类。 常见的无监督学习任务是在训练数据内找到群集。

我们还可以将聚类定义为基于某些类似特征将给定集合的项目组织成组的过程。 例如，在线新闻发布者使用群集对其新闻文章进行分组。

聚类的应用

聚类在许多领域中找到应用，例如市场研究，模式识别，数据分析和图像处理。这里讨论 -

• 帮助营销人员在客户基础上发现不同的群体，并根据购买模式描述他们的客户群体。

• 在生物学中，它可以用于推导植物和动物分类，对具有相似功能的基因进行分类，并深入了解群体中固有的结构。

• 帮助确定地球观测数据库中类似土地利用的区域。

• 帮助对Web上的文档进行分类以便发现信息。

• 用于异常检测应用，如检测信用卡欺诈。

• 聚类分析用作数据挖掘功能工具，以深入了解数据分布，以观察每个聚类的特征。

这项任务称为聚类或聚类分析，将观察结果分配给各组，使得组内观察结果基于某些相似性度量彼此更相似，而不是其他组中的观察结果。

聚类通常用于探索数据集。 例如，给定一组电影评论，聚类算法可能会发现一组正面和负面评论。 系统将无法将群集标记为“正面”或“负面”; 在没有监督的情况下，只有通过某种程度才能知道分组观察结果彼此相似。 群集的一个常见应用是发现产品市场中的客户群。 通过了解特定客户群的共同属性，营销人员可以决定需要强调其广告系列的哪些方面。 互联网无线电业务也使用集群; 例如，给定一组歌曲，聚类算法可能能够根据它们的类型对歌曲进行分组。 使用不同的相似性度量，相同的聚类算法可以通过它们的键或它们包含的乐器对歌曲进行分组。

无监督学习任务包括聚类，其中根据某些类似特征将观察组织成组。 聚类用于基于共同特征形成类似数据的组或集群。

聚类是一种无监督学习的形式。 搜索引擎，如Google，Bing和Yahoo! 使用聚类技术对具有相似特征的数据进行分组。 新闻组使用群集技术根据相关主题对各种文章进行分组。

集群引擎完全通过输入数据，并根据数据的特征，决定在哪个集群下进行分组。 在聚类时可能会注意到以下几点 -

• 将选择合适的聚类算法以对聚类的元素进行分组。

• 需要一个规则来验证新遇到的元素与组中元素之间的相似性。

• 需要停止条件来定义不需要聚类的点。

聚类类型

有两种类型的聚类 - flat clustering和hierarchical clustering 。

平面聚类创建一组平面聚类，没有任何可以将聚类相互关联的清晰结构。 分层聚类创建聚类层次结构。 分层聚类将聚类的层次结构作为输出，这种结构比平面聚类返回的非结构化聚类集产生更多信息。 分层聚类不需要我们事先指定聚类的数量。 分层聚类的优点是以降低效率为代价的。

一般来说，当效率很重要时，我们选择平面聚类，当平面聚类的潜在问题之一是问题时，我们选择层次聚类。 此外，许多研究人员认为，层次聚类比平面聚类产生更好的聚类。

聚类算法

您需要聚类算法来聚合给定数据。 经常使用两种算法 - Canopy clustering和K-Means clustering 。

冠层聚类算法是一种无监督的预聚类算法，通常用作K均值算法或分层聚类算法的预处理步骤。 它用于加速大型数据集上的聚类操作，由于数据集的大小，可能无法直接使用其他算法。

K均值聚类是一种重要的聚类算法。 k均值聚类算法中的k表示数据被分成的聚类数。 例如，如果算法中指定的k值为3，则算法将数据划分为3个簇。

每个对象都表示为空间中的向量。 最初由算法随机选择k个点并将其视为中心，最靠近每个中心的每个对象都被聚类。 k-means算法需要矢量文件作为输入，因此我们需要创建矢量文件。 在创建向量之后，我们继续使用k-means算法。

Machine Learning with Python - Algorithms

机器学习算法可大致分为两种类型 - Supervised和非Unsupervised 。 本章将详细讨论它们。

监督学习

该算法由目标或结果或因变量组成，该变量是从给定的一组预测变量或自变量预测的。 使用这些变量集，我们生成一个将输入变量映射到所需输出变量的函数。 训练过程一直持续到模型在训练数据上达到所需的准确度。

监督学习的例子 - 回归，决策树，随机森林，KNN，Logistic回归等。

无监督学习

在该算法中，没有目标或结果或因变量来预测或估计。 它用于将给定数据集聚类到不同的组中，广泛用于将客户划分为不同的组以进行特定干预。 Apriori算法和K-means是无监督学习的一些例子。

强化学习

使用该算法，机器经过训练以做出具体决定。 在这里，算法通过使用试错法和反馈方法不断训练自己。 该机器从过去的经验中学习，并尝试捕获最佳可能的知识，以做出准确的业务决策。

马尔可夫决策过程是强化学习的一个例子。

常用机器学习算法列表

以下是几乎可用于任何数据问题的常用机器学习算法列表 -

• 线性回归
• Logistic Regression
• 决策树
• SVM
• 朴素贝叶斯
• KNN
• K-Means
• 随机森林
• 降维算法
• Gradient Boosting算法，如GBM，XGBoost，LightGBM和CatBoost

本节详细讨论了每一个 -

线性回归

线性回归用于基于连续变量估计真实世界值，例如房屋成本，呼叫数量，总销售额等。 在这里，我们通过拟合最佳线来建立依赖变量和自变量之间的关系。 这条最佳拟合线称为regression line ，由线性方程Y= a *X + b 。

在这个等式中 -

Y - 因变量

a - 坡度

X - 自变量

b - 拦截

这些系数a和b是基于最小化数据点和回归线之间的距离的平方差的总和而导出的。

例子 (Example)

理解线性回归的最佳方法是考虑一个例子。 假设我们被要求按照其权重的递增顺序安排学生上课。 通过观察学生并在视觉上分析他们的高度和构建，我们可以根据需要使用这些参数（高度和构建）的组合来安排它们。 这是现实世界的线性回归示例。 我们已经发现高度和构造通过关系与权重相关，这看起来类似于上面的等式。

线性回归的类型

线性回归主要有两种类型 - Simple Linear Regression和Multiple Linear Regression 。 简单线性回归的特征在于一个独立变量，而多元线性回归的特征在于多个独立变量。 在找到最佳拟合线时，您可以拟合多项式或曲线回归。 您可以使用以下代码来实现此目的。

import matplotlib.pyplot as plt
plt.scatter(X, Y)
yfit = [a + b * xi for xi in X]
plt.plot(X, yfit)

构建线性回归器

回归是估计输入数据和连续值输出数据之间关系的过程。 这些数据通常采用实数形式，我们的目标是估计控制从输入到输出的映射的基础函数。

考虑输入和输出之间的映射，如图所示 -

1 --> 2
3 --> 6
4.3 --> 8.6
7.1 --> 14.2

通过分析模式，您可以轻松估计输入和输出之间的关系。 我们可以观察到输出是每种情况下输入值的两倍，因此转换将是 - f(x) = 2x

线性回归是指使用输入变量的线性组合来估计相关函数。 前面的示例是一个由一个输入变量和一个输出变量组成的示例。

线性回归的目标是提取将输入变量与输出变量相关联的相关线性模型。 这旨在使用线性函数最小化实际输出和预测输出之间的差的平方和。 这种方法称为Ordinary Least Squares 。 您可以假设那里的弯曲线更适合这些点，但线性回归不允许这样做。 线性回归的主要优点是它并不复杂。 您也可以在非线性回归中找到更准确的模型，但它们会更慢。 这里，模型尝试使用直线近似输入数据点。

让我们了解如何在Python中构建线性回归模型。

请考虑为您提供了一个名为data_singlevar.txt的数据文件。 它包含以逗号分隔的行，其中第一个元素是输入值，第二个元素是与此输入值对应的输出值。 你应该使用它作为输入参数 -

假设最适合一组积分的线是 -

y = a + b * x

其中b =（sum（xi * yi） - n * xbar * ybar）/ sum（（xi - xbar）^ 2）

a = ybar - b * xbar

为此目的使用以下代码 -

# sample points
X = [0, 6, 11, 14, 22]
Y = [1, 7, 12, 15, 21]
# solve for a and b
def best_fit(X, Y):
   xbar = sum(X)/len(X)
   ybar = sum(Y)/len(Y)
   n = len(X) # or len(Y)
   numer = sum([xi*yi for xi,yi in zip(X, Y)]) - n * xbar * ybar
   denum = sum([xi**2 for xi in X]) - n * xbar**2
   b = numer/denum
   a = ybar - b * xbar
   print('best fit line:\ny = {:.2f} + {:.2f}x'.format(a, b))
   return a, b
# solution
a, b = best_fit(X, Y)
#best fit line:
#y = 0.80 + 0.92x
# plot points and fit line
import matplotlib.pyplot as plt
plt.scatter(X, Y)
yfit = [a + b * xi for xi in X]
plt.plot(X, yfit)
plt.show()
best fit line:
y = 1.48 + 0.92x

如果运行上面的代码，您可以观察输出图形，如图所示 -

请注意，此示例仅使用糖尿病数据集的第一个特征，以说明此回归技术的二维图。 在图中可以看到直线，显示线性回归如何尝试绘制直线，这将最好地最小化数据集中观察到的响应之间的残差平方和线性近似预测的响应。

您可以使用下面显示的程序代码计算系数，残差平方和方差分数 -

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score
# Load the diabetes dataset
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]
# Split the data into training/testing sets
diabetes_X_train = diabetes_X[:-30]
diabetes_X_test = diabetes_X[-30:]
# Split the targets into training/testing sets
diabetes_y_train = diabetes.target[:-30]
diabetes_y_test = diabetes.target[-30:]
# Create linear regression object
regr = linear_model.LinearRegression()
# Train the model using the training sets
regr.fit(diabetes_X_train, diabetes_y_train)
# Make predictions using the testing set
diabetes_y_pred = regr.predict(diabetes_X_test)
# The coefficients
print('Coefficients: \n', regr.coef_)
# The mean squared error
print("Mean squared error: %.2f" 
      % mean_squared_error(diabetes_y_test, diabetes_y_pred))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(diabetes_y_test, diabetes_y_pred))
# Plot outputs
plt.scatter(diabetes_X_test, diabetes_y_test, color = 'black')
plt.plot(diabetes_X_test, diabetes_y_pred, color = 'blue', linewidth = 3)
plt.xticks(())
plt.yticks(())
plt.show()

执行上面给出的代码后，您可以观察到以下输出 -

Automatically created module for IPython interactive environment
('Coefficients: \n', array([ 941.43097333]))
Mean squared error: 3035.06
Variance score: 0.41

Logistic回归

逻辑回归是机器学习从统计学中借用的另一种技术。 它是二进制分类问题的首选方法，即两个类值的问题。

它是一种分类算法，而不是名称所示的回归算法。 它用于根据给定的自变量集估计离散值或值，如0/1，Y/N，T/F. 它通过将数据拟合到logit函数来预测事件发生的概率。 因此，它也被称为logit regression 。 因为，它预测概率，其输出值介于0和1之间。

例子 (Example)

让我们通过一个简单的例子来理解这个算法。

假设有一个难题要解决，只有2个结果场景 - 要么有解决方案要么没有解决方案。 现在假设，我们有各种各样的谜题来测试一个人擅长哪些科目。 结果可能是这样的 - 如果给出三角拼图，一个人可能有80％的可能解决它。 另一方面，如果给出地理谜题，那么该人可能只有20％可能解决它。 这是Logistic回归有助于解决的问题。 根据数学，结果的对数几率表示为预测变量的线性组合。

odds = p/ (1-p) = probability of event occurrence/probability of not event occurrence
ln(odds) = ln(p/(1-p)) ; ln is the logarithm to the base ‘e’.
logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk

注意，在上面的p是存在感兴趣特征的概率。 它选择的参数最大化观察样本值的可能性，而不是最小化误差平方和（如普通回归）。

请注意，记录日志是复制步进函数的最佳数学方法之一。

在进行逻辑回归时，以下几点值得注意 -

• 它与回归类似，其目的是找到权衡每个输入变量的系数的值。

• 与线性回归不同，使用称为逻辑函数的非线性函数找到输出的预测。

• 逻辑函数看起来像一个大'S'并且会将任何值更改为0到1的范围。这很有用，因为我们可以将规则应用于逻辑函数的输出，以将值分配给0和1并预测类值。

• 学习逻辑回归模型的方式，由它做出的预测也可以用作属于0级或1级的给定数据实例的概率。这对于需要为预测提供更多推理的问题非常有用。 。

• 与线性回归一样，当删除输出变量的不相关属性并删除类似属性时，逻辑回归效果更好。

以下代码显示了如何使用逻辑曲线开发逻辑表达式的绘图，其中合成数据集被分类为值0或1，即一类或二类。

import numpy as np
import matplotlib.pyplot as plt
from sklearn import linear_model
# This is the test set, it's a straight line with some Gaussian noise
xmin, xmax = -10, 10
n_samples = 100
np.random.seed(0)
X = np.random.normal(size = n_samples)
y = (X > 0).astype(np.float)
X[X > 0] *= 4
X += .3 * np.random.normal(size = n_samples)
X = X[:, np.newaxis]
# run the classifier
clf = linear_model.LogisticRegression(C=1e5)
clf.fit(X, y)
# and plot the result
plt.figure(1, figsize = (4, 3))
plt.clf()
plt.scatter(X.ravel(), y, color='black', zorder=20)
X_test = np.linspace(-10, 10, 300)
def model(x):
return 1/(1 + np.exp(-x))
loss = model(X_test * clf.coef_ + clf.intercept_).ravel()
plt.plot(X_test, loss, color='blue', linewidth=3)
ols = linear_model.LinearRegression()
ols.fit(X, y)
plt.plot(X_test, ols.coef_ * X_test + ols.intercept_, linewidth=1)
plt.axhline(.5, color='.5')
plt.ylabel('y')
plt.xlabel('X')
plt.xticks(range(-10, 10))
plt.yticks([0, 0.5, 1])
plt.ylim(-.25, 1.25)
plt.xlim(-4, 10)
plt.legend(('Logistic Regression Model', 'Linear Regression Model'),
loc="lower right", fontsize='small')
plt.show()

输出图如下所示 -

决策树算法

它是一种监督学习算法，主要用于分类问题。 它适用于离散和连续因变量。 在该算法中，我们将总体分成两个或更多个同类集。 这是基于最重要的属性来完成的，以尽可能地作为不同的组。

决策树广泛用于机器学习，包括分类和回归。 在决策分析中，决策树用于在视觉上和明确地表示决策和决策。 它使用树状的决策模型。

绘制决策树，其根部位于顶部，分支位于底部。 在图像中，粗体文本表示条件/内部节点，树基于该节点/内部节点分割成分支/边缘。 不再分裂的分支端是决策/叶子。

例子 (Example)

考虑使用泰坦尼克数据集来预测乘客是否能够存活的示例。 下面的模型使用数据集中的3个特征/属性/列，即性别，年龄和sibsp（没有配偶/子女）。 在这种情况下，乘客是否死亡或幸存，分别表示为红色和绿色文本。

在一些示例中，我们看到基于多个属性将群体分类到不同的群组中以识别“他们是否做某事”。 为了将人口分成不同的异构群体，它使用各种技术，如基尼，信息增益，卡方，熵等。

理解决策树如何工作的最好方法是玩Jezzball--一款来自微软的经典游戏。 基本上，在这个游戏中，你有一个移动墙壁的房间，你需要创建墙壁，以便在没有球的情况下清除最大区域。

因此，每次你用墙隔开房间时，你都试图在同一个房间里创造2个不同的人口。 决策树以非常类似的方式工作，通过将人口分成尽可能不同的群体。

观察下面给出的代码及其输出 -

#Starting implementation
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
%matplotlib inline
from sklearn import tree
df = pd.read_csv("iris_df.csv")
df.columns = ["X1", "X2", "X3","X4", "Y"]
df.head()
#implementation
from sklearn.cross_validation import train_test_split
decision = tree.DecisionTreeClassifier(criterion="gini")
X = df.values[:, 0:4]
Y = df.values[:, 4]
trainX, testX, trainY, testY = train_test_split( X, Y, test_size = 0.3)
decision.fit(trainX, trainY)
print("Accuracy: \n", decision.score(testX, testY))
#Visualisation
from sklearn.externals.six import StringIO
from IPython.display import Image
import pydotplus as pydot
dot_data = StringIO()
tree.export_graphviz(decision, out_file=dot_data)
graph = pydot.graph_from_dot_data(dot_data.getvalue())
Image(graph.create_png())

Output

Accuracy:
0.955555555556

例子 (Example)

在这里，我们使用钞票认证数据集来了解准确性。

# Using the Bank Note dataset
from random import seed
from random import randrange
from csv import reader
# Loading a CSV file
filename ='data_banknote_authentication.csv'
def load_csv(filename):
   file = open(filename, "rb")
   lines = reader(file)
   dataset = list(lines)
   return dataset
# Convert string column to float
def str_column_to_float(dataset, column):
   for row in dataset:
      row[column] = float(row[column].strip())
# Split a dataset into k folds
def cross_validation_split(dataset, n_folds):
   dataset_split = list()
   dataset_copy = list(dataset)
   fold_size = int(len(dataset)/n_folds)
   for i in range(n_folds):
      fold = list()
      while len(fold) < fold_size:
         index = randrange(len(dataset_copy))
         fold.append(dataset_copy.pop(index))
      dataset_split.append(fold)
   return dataset_split
# Calculating accuracy percentage
def accuracy_metric(actual, predicted):
correct = 0
for i in range(len(actual)):
if actual[i] == predicted[i]:
correct += 1
return correct/float(len(actual)) * 100.0
# Evaluating an algorithm using a cross validation split
def evaluate_algorithm(dataset, algorithm, n_folds, *args):
   folds = cross_validation_split(dataset, n_folds)
   scores = list()
   for fold in folds:
      train_set = list(folds)
      train_set.remove(fold)
      train_set = sum(train_set, [])
      test_set = list()
      for row in fold:
         row_copy = list(row)
         test_set.append(row_copy)
         row_copy[-1] = None
      predicted = algorithm(train_set, test_set, *args)
      actual = [row[-1] for row in fold]
      accuracy = accuracy_metric(actual, predicted)
      scores.append(accuracy)
   return scores
# Splitting a dataset based on an attribute and an attribute value
def test_split(index, value, dataset):
   left, right = list(), list()
   for row in dataset:
      if row[index] < value:
         left.append(row)
      else:
         right.append(row)
   return left, right
# Calculating the Gini index for a split dataset
def gini_index(groups, classes):
   # count all samples at split point
   n_instances = float(sum([len(group) for group in groups]))
   # sum weighted Gini index for each group
   gini = 0.0
   for group in groups:
      size = float(len(group))
      # avoid divide by zero
      if size == 0:
         continue
      score = 0.0
      # score the group based on the score for each class
      for class_val in classes:
         p = [row[-1] for row in group].count(class_val)/size
      score += p * p
      # weight the group score by its relative size
      gini += (1.0 - score) * (size/n_instances)
return gini
# Selecting the best split point for a dataset
def get_split(dataset):
   class_values = list(set(row[-1] for row in dataset))
   b_index, b_value, b_score, b_groups = 999, 999, 999, None
   for index in range(len(dataset[0])-1):
      for row in dataset:
         groups = test_split(index, row[index], dataset)
         gini = gini_index(groups, class_values)
         if gini < b_score:
            b_index, b_value, b_score, b_groups = index, 
row[index], gini, groups
   return {'index':b_index, 'value':b_value, 'groups':b_groups}
# Creating a terminal node value
def to_terminal(group):
outcomes = [row[-1] for row in group]
return max(set(outcomes), key=outcomes.count)
# Creating child splits for a node or make terminal
def split(node, max_depth, min_size, depth):
   left, right = node['groups']
   del(node['groups'])
   # check for a no split
   if not left or not right:
      node['left'] = node['right'] = to_terminal(left + right)
      return
   # check for max depth
   if depth >= max_depth:
      node['left'], node['right'] = to_terminal(left), to_terminal(right)
      return
   # process left child
   if len(left) <= min_size:
      node['left'] = to_terminal(left)
   else:
      node['left'] = get_split(left)
      split(node['left'], max_depth, min_size, depth+1)
   # process right child
   if len(right) <= min_size:
      node['right'] = to_terminal(right)
   else:
      node['right'] = get_split(right)
      split(node['right'], max_depth, min_size, depth+1)
# Building a decision tree
def build_tree(train, max_depth, min_size):
   root = get_split(train)
   split(root, max_depth, min_size, 1)
   return root
# Making a prediction with a decision tree
   def predict(node, row):
   if row[node['index']] < node['value']:
      if isinstance(node['left'], dict):
         return predict(node['left'], row)
      else:
         return node['left']
   else:
      if isinstance(node['right'], dict):
         return predict(node['right'], row)
      else:
         return node['right']
# Classification and Regression Tree Algorithm
def decision_tree(train, test, max_depth, min_size):
   tree = build_tree(train, max_depth, min_size)
   predictions = list()
   for row in test:
      prediction = predict(tree, row)
      predictions.append(prediction)
   return(predictions)
# Testing the Bank Note dataset
seed(1)
# load and prepare data
filename = 'data_banknote_authentication.csv'
dataset = load_csv(filename)
# convert string attributes to integers
for i in range(len(dataset[0])):
   str_column_to_float(dataset, i)
# evaluate algorithm
n_folds = 5
max_depth = 5
min_size = 10
scores = evaluate_algorithm(dataset, decision_tree, n_folds, max_depth, min_size)
print('Scores: %s' % scores)
print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores))))

当您执行上面给出的代码时，您可以按如下方式观察输出 -

Scores: [95.62043795620438, 97.8102189781022, 97.8102189781022, 
94.52554744525547, 98.90510948905109]
Mean Accuracy: 96.934%

Support Vector Machines (SVM)

支持向量机，也称为SVM，是众所周知的监督分类算法，用于分离不同类别的数据。

通过优化线来对这些矢量进行分类，使得每个组中的最近点将彼此最远。

此向量默认为线性，并且通常也可视为线性。 但是，如果内核类型从默认类型“高斯”或线性变化，则矢量也可以采用非线性形式。

它是一种分类方法，其中我们将每个数据项绘制为n维空间中的点（其中n是要素的数量），每个要素的值是特定坐标的值。

例如，如果我们只有两个特征，如个体的Height和Hair length ，我们应该首先在二维空间中绘制这两个变量，其中每个点有两个坐标称为支持向量。 请注意以下图表以便更好地理解 -

现在，找到一些在两个不同分类的数据组之间分割数据的行。 这将是这样的线，使得距离两组中的每一组中的最近点的距离将最远。

在上面示出的示例中，将数据分成两个不同分类的组的线是黑线，因为两个最接近的点距离线最远。 这一行是我们的分类器。 然后，根据测试数据在线路两侧的位置，我们可以对新数据进行分类。

from sklearn import svm
df = pd.read_csv('iris_df.csv')
df.columns = ['X4', 'X3', 'X1', 'X2', 'Y']
df = df.drop(['X4', 'X3'], 1)
df.head()
from sklearn.cross_validation import train_test_split
support = svm.SVC()
X = df.values[:, 0:2]
Y = df.values[:, 2]
trainX, testX, trainY, testY = train_test_split( X, Y, test_size = 0.3)
sns.set_context('notebook', font_scale=1.1)
sns.set_style('ticks')
sns.lmplot('X1','X2', scatter=True, fit_reg=False, data=df, hue='Y')
plt.ylabel('X2')
plt.xlabel('X1')

运行上面显示的代码时，您会注意到以下输出和绘图 -

Text(0.5,27.256,'X1')

朴素贝叶斯算法

它是一种基于贝叶斯定理的分类技术，假设预测变量是独立的。 简单来说，朴素贝叶斯分类器假定类中特定特征的存在与任何其他特征的存在无关。

例如，如果果实是橙色，圆形，直径约3英寸，则可以认为果实是橙色。 即使这些特征彼此依赖或依赖于其他特征的存在，一个朴素的贝叶斯分类器会认为所有这些特征独立地促成了这种果实是橙色的概率。

朴素贝叶斯模型很容易制作，特别适用于非常大的数据集。 除了简单之外，Naive Bayes的表现甚至超过了先进的分类方法。

贝叶斯定理提供了一种从P（c），P（x）和P（x | c）计算后验概率P（c | x）的方法。 观察这里提供的等式: P(c/x) = P(x/c)P(c)/P(x)

Where,

P（c | x）是给定预测器（属性）的类（目标）的后验概率。

P（c）是先验概率。

P（x | c）是给定类别的预测概率的似然性。

P（x）是预测器的先验概率。

考虑下面给出的示例以便更好地理解 -

假设Weather训练数据集和相应的目标变量Play 。 现在，我们需要根据天气情况对玩家是否玩游戏进行分类。 为此，您必须采取以下步骤 -

Step 1 - 将数据集转换为频率表。

Step 2 - 通过找到阴天概率= 0.29和播放概率为0.64的概率来创建似然表。

Step 3 - 现在，使用朴素贝叶斯方程计算每个类的后验概率。 具有最高后验概率的类是预测的结果。

Problem - 如果天气晴朗，玩家会玩，这个说法是否正确？

Solution - 我们可以使用上面讨论的方法解决它，所以P（是| Sunny）= P( Sunny | Yes) * P(Yes)/P (Sunny)

我们有，P（晴天|是）= 3/9 = 0.33，P（晴天）= 5/14 = 0.36，P（是）= 9/14 = 0.64

现在，P（是| Sunny）= 0.33 * 0.64/0.36 = 0.60，具有更高的概率。

Naive Bayes使用类似的方法根据各种属性预测不同类别的概率。 该算法主要用于文本分类，并且具有多个类的问题。

以下代码显示了朴素贝叶斯实现的示例 -

import csv
import random
import math
def loadCsv(filename):
   lines = csv.reader(open(filename, "rb"))
   dataset = list(lines)
   for i in range(len(dataset)):
      dataset[i] = [float(x) for x in dataset[i]]
   return dataset
def splitDataset(dataset, splitRatio):
   trainSize = int(len(dataset) * splitRatio)
   trainSet = []
   copy = list(dataset)
   while len(trainSet) < trainSize:
      index = random.randrange(len(copy))
      trainSet.append(copy.pop(index))
   return [trainSet, copy]
def separateByClass(dataset):
   separated = {}
   for i in range(len(dataset)):
      vector = dataset[i]
      if (vector[-1] not in separated):
         separated[vector[-1]] = []
      separated[vector[-1]].append(vector)
return separated
def mean(numbers):
return sum(numbers)/float(len(numbers))
def stdev(numbers):
   avg = mean(numbers)
   variance = sum([pow(x-avg,2) for x in numbers])/float(len(numbers)-1)
   return math.sqrt(variance)
def summarize(dataset):
   summaries = [(mean(attribute), stdev(attribute)) for attribute in zip(*dataset)]
def summarizeByClass(dataset):
   separated = separateByClass(dataset)
   summaries = {}
   for classValue, instances in separated.iteritems():
      summaries[classValue] = summarize(instances)
   return summaries
def calculateProbability(x, mean, stdev):
   exponent = math.exp(-(math.pow(x-mean,2)/(2*math.pow(stdev,2))))
   return (1/(math.sqrt(2*math.pi) * stdev)) * exponent
def calculateClassProbabilities(summaries, inputVector):
   probabilities = {}
   for classValue, classSummaries in summaries.iteritems():
      probabilities[classValue] = 1
      for i in range(len(classSummaries)):
      mean, stdev = classSummaries[i]
      x = inputVector[i]
      probabilities[classValue] *= calculateProbability(x, mean,stdev)
   return probabilities
def predict(summaries, inputVector):
   probabilities = calculateClassProbabilities(summaries, inputVector)
   bestLabel, bestProb = None, -1
   for classValue, probability in probabilities.iteritems():
      if bestLabel is None or probability > bestProb:
         bestProb = probability
         bestLabel = classValue
   return bestLabel
def getPredictions(summaries, testSet):
   predictions = []
   for i in range(len(testSet)):
      result = predict(summaries, testSet[i])
      predictions.append(result)
   return predictions
def getAccuracy(testSet, predictions):
   correct = 0
   for i in range(len(testSet)):
      if testSet[i][-1] == predictions[i]:
         correct += 1
   return (correct/float(len(testSet))) * 100.0
def main():
   filename = 'pima-indians-diabetes.data.csv'
   splitRatio = 0.67
   dataset = loadCsv(filename)
   trainingSet, testSet = splitDataset(dataset, splitRatio)
   print('Split {0} rows into train = {1} and test = {2} rows').format(len(dataset), len(trainingSet), len(testSet))
   # prepare model
   summaries = summarizeByClass(trainingSet)
   # test model
   predictions = getPredictions(summaries, testSet)
   accuracy = getAccuracy(testSet, predictions)
   print('Accuracy: {0}%').format(accuracy)
main()

当您运行上面给出的代码时，您可以观察以下输出 -

Split 1372 rows into train = 919 and test = 453 rows
Accuracy: 83.6644591611%

KNN (K-Nearest Neighbours)

K-Nearest Neighbors，简称KNN，是一种专门用于分类的监督学习算法。 这是一种简单的算法，可以存储所有可用的案例，并通过其k个邻居的多数投票对新案例进行分类。 分配给该类的情况是由距离函数测量的其K个最近邻居中最常见的情况。 这些距离函数可以是欧几里德，曼哈顿，闵可夫斯基和汉明距离。 前三个函数用于连续函数，第四个函数用于分类变量（汉明）。 如果K = 1，则将该情况简单地分配给其最近邻居的类。 有时，在执行KNN建模时，选择K结果是一个挑战。

该算法查看不同的质心并使用某种函数（通常是欧几里得）比较距离，然后分析这些结果并将每个点分配给该组，以便优化它以放置所有最接近的点。

您可以将KNN用于分类和回归问题。 然而，它更广泛地用于工业中的分类问题。 KNN很容易映射到我们的现实生活中。

在选择KNN之前，您必须注意以下几点 -

• KNN在计算上很昂贵。

• 变量应该归一化，否则更高范围的变量会偏向它。

• 在进行KNN之前更多的是在预处理阶段工作，例如异常值，噪声消除

请仔细阅读以下代码以更好地了解KNN -

#Importing Libraries
from sklearn.neighbors import KNeighborsClassifier
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create KNeighbors classifier object model
KNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 5
# Train the model using the training sets and check score
model.fit(X, y)
#Predict Output
predicted= model.predict(x_test)
from sklearn.neighbors import KNeighborsClassifier
df = pd.read_csv('iris_df.csv')
df.columns = ['X1', 'X2', 'X3', 'X4', 'Y']
df = df.drop(['X4', 'X3'], 1)
df.head()
sns.set_context('notebook', font_scale=1.1)
sns.set_style('ticks')
sns.lmplot('X1','X2', scatter=True, fit_reg=False, data=df, hue='Y')
plt.ylabel('X2')
plt.xlabel('X1')
from sklearn.cross_validation import train_test_split
neighbors = KNeighborsClassifier(n_neighbors=5)
X = df.values[:, 0:2]
Y = df.values[:, 2]
trainX, testX, trainY, testY = train_test_split( X, Y, test_size = 0.3)
neighbors.fit(trainX, trainY)
print('Accuracy: \n', neighbors.score(testX, testY))
pred = neighbors.predict(testX)

上面给出的代码将产生以下输出 -

('Accuracy: \n', 0.75555555555555554)

K-Means

它是一种处理聚类问题的无监督算法。 它的过程遵循一种简单易行的方法，通过一定数量的簇（假设k簇）对给定数据集进行分类。 集群内的数据点是同构的，并且与对等组是异构的。

K-means如何形成集群

K-means在以下步骤中形成集群 -

• K-means为称为质心的每个簇选择k个点。

• 每个数据点形成具有最近质心的簇，即k簇。

• 根据现有集群成员查找每个集群的质心。 在这里，我们有新的质心。

当我们有新的质心时，重复步骤2和3.找到每个数据点与新质心的最近距离，并与新的k-簇相关联。 重复此过程直到收敛发生，直到质心不变。

K的值的确定

在K-means中，我们有集群，每个集群都有自己的质心。 质心与簇内数据点之间的差的平方和构成该簇的平方值之和。 此外，当添加所有聚类的平方值之和时，它在聚类解的平方值之和内变为总和。

我们知道随着聚类数量的增加，这个值会继续下降，但是如果你绘制结果，你可能会看到平方距离之和急剧下降到某个k值，然后慢得多。 在这里，我们可以找到最佳的簇数。

请注意以下代码 -

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")
from sklearn.cluster import KMeans
x = [1, 5, 1.5, 8, 1, 9]
y = [2, 8, 1.8, 8, 0.6, 11]
plt.scatter(x,y)
plt.show()
X = np.array([ [1, 2],
               [5, 8],
               [1.5, 1.8],
               [8, 8],
               [1, 0.6],
               [9, 11]])
kmeans = KMeans(n_clusters=2)
kmeans.fit(X)
centroids = kmeans.cluster_centers_
labels = kmeans.labels_
print(centroids)
print(labels)
colors = ["g.","r.","c.","y."]
for i in range(len(X)):
   print("coordinate:",X[i], "label:", labels[i])
   plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 10)
plt.scatter(centroids[:, 0],centroids[:, 1], marker = "x", s=150, linewidths = 5, zorder = 10)
plt.show()

当您运行上面给出的代码时，您可以看到以下输出 -

[ [ 1.16666667 1.46666667] [ 7.33333333 9. ] ]
[0 1 0 1 0 1]
('coordinate:', array([ 1., 2.]), 'label:', 0)
('coordinate:', array([ 5., 8.]), 'label:', 1)
('coordinate:', array([ 1.5, 1.8]), 'label:', 0)
('coordinate:', array([ 8., 8.]), 'label:', 1)
('coordinate:', array([ 1. , 0.6]), 'label:', 0)
('coordinate:', array([ 9., 11.]), 'label:', 1)

这是您理解的另一个代码 -

from sklearn.cluster import KMeans
df = pd.read_csv('iris_df.csv')
df.columns = ['X1', 'X2', 'X3', 'X4', 'Y']
df = df.drop(['X4', 'X3'], 1)
df.head()
from sklearn.cross_validation import train_test_split
kmeans = KMeans(n_clusters = 3)
X = df.values[:, 0:2]
kmeans.fit(X)
df['Pred'] = kmeans.predict(X)
df.head()
sns.set_context('notebook', font_scale = 1.1)
sns.set_style('ticks')
sns.lmplot('X1','X2', scatter = True, fit_reg = False, data = df, hue = 'Pred')

以下是上述代码的输出 -

<seaborn.axisgrid.FacetGrid at 0x107ad6a0>

随机森林

随机森林是一种流行的监督集成学习算法。 “合奏”意味着它需要一堆“弱学习者”，让他们共同努力，形成一个强有力的预测者。 在这种情况下，弱学习者都是随机实施的决策树，这些决策树汇集在一起​​形成强预测器 - 随机森林。

请注意以下代码 -

from sklearn.ensemble import RandomForestClassifier
df = pd.read_csv('iris_df.csv')
df.columns = ['X1', 'X2', 'X3', 'X4', 'Y']
df.head()
from sklearn.cross_validation import train_test_split
forest = RandomForestClassifier()
X = df.values[:, 0:4]
Y = df.values[:, 4]
trainX, testX, trainY, testY = train_test_split( X, Y, test_size = 0.3)
forest.fit(trainX, trainY)
print('Accuracy: \n', forest.score(testX, testY))
pred = forest.predict(testX)

上面给出的代码的输出是 -

('Accuracy: \n', 1.0)

集合方法的目标是结合使用给定学习算法构建的几个基本估计器的预测，以便改善单个估计器的可普遍性/鲁棒性。

sklearn.ensemble模块包括两个基于随机决策树的平均算法 - the RandomForest algorithm和Extra-Trees method 。 两种算法都是专为树木设计的扰动和组合技术[B1998]。 这意味着通过在分类器构造中引入随机性来创建多种分类器。 集合的预测作为各个分类器的平均预测给出。

森林分类器必须配备两个阵列 - 一个大小为[n_samples，n_features]的稀疏或密集阵列X，用于保存训练样本;一个大小为[n_samples]的阵列Y，用于保存训练样本的目标值（类标签），如下面的代码所示 -

>>> from sklearn.ensemble import RandomForestClassifier
>>> X = [[0, 0], [1, 1]]
>>> Y = [0, 1]
>>> clf = RandomForestClassifier(n_estimators = 10)
>>> clf = clf.fit(X, Y)

与决策树一样，树木的森林也会扩展到多输出问题（如果Y是一个大小为[n_samples，n_outputs]的数组）。

与原始出版物[B2001]相反， scikit-learn实现通过平均其概率预测来组合分类器，而不是让每个分类器对单个类别进行投票。

随机森林是决策树集合的商标用语。 在随机森林中，我们有一组决策树，称为“森林”。 为了根据属性对新对象进行分类，每个树都给出一个分类，我们说该树为该类“投票”。 森林选择得票最多的分类（在森林中的所有树木上）。

每棵树的种植和种植如下 -

• 如果训练集中的病例数是N，那么N个病例的样本是随机抽取的，但需要替换。 此示例将是用于种植树的训练集。

• 如果存在M个输入变量，则指定数量m << M，使得在每个节点处，从M中随机选择m个变量，并且使用这些m上的最佳分割来分割节点。 在森林生长期间，m的值保持不变。

• 每棵树都尽可能地生长。 没有修剪。

维数减少算法

维度降低是另一种常见的无监督学习任务。 一些问题可能包含数万甚至数百万的输入或解释变量，这些工作和计算可能代价高昂。 此外，如果某些输入变量捕获噪声或与基础关系无关，则程序的泛化能力可能会降低。

维度减少是查找输出变量的过程，这些变量负责输出或响应变量的最大变化。 降维有时也用于可视化数据。 很容易想象回归问题，例如从其大小预测属性的价格，可以沿着图的x轴绘制属性的大小，并且可以沿y轴绘制属性的价格。 类似地，当添加第二解释变量时，很容易可视化房产价格回归问题。 例如，可以在z轴上绘制房产中的房间数量。 然而，数千个输入变量的问题变得不可能可视化。

降维，将一组非常大的解释变量输入减少到一组较小的输入变量，以保留尽可能多的信息。

PCA是一种降维算法，可以为数据分析做有用的事情。 最重要的是，它可以在处理数百或数千个不同的输入变量时显着减少模型中涉及的计算次数。 由于这是一项无监督的学习任务，用户仍然需要分析结果并确保它们保持原始数据集行为的95％左右。

请注意以下代码以便更好地理解 -

from sklearn import decomposition
df = pd.read_csv('iris_df.csv')
df.columns = ['X1', 'X2', 'X3', 'X4', 'Y']
df.head()
from sklearn import decomposition
pca = decomposition.PCA()
fa = decomposition.FactorAnalysis()
X = df.values[:, 0:4]
Y = df.values[:, 4]
train, test = train_test_split(X,test_size = 0.3)
train_reduced = pca.fit_transform(train)
test_reduced = pca.transform(test)
pca.n_components_

您可以看到上面给出的代码的以下输出 -

4L

在过去的5年中，每个可能的水平和点都有数据捕获量呈指数增长。 政府机构/研究机构/企业不仅提供新的数据来源，而且还在几个点和阶段捕获非常详细的数据。

例如，电子商务公司正在捕获有关客户的更多详细信息，例如他们的人口统计，浏览历史，他们的喜欢或不喜欢，购买历史，反馈和其他一些细节，以给他们定制的关注。 现在可用的数据可能具有数千个功能，并且在保留尽可能多的信息的同时减少这些功能是一项挑战。 在这种情况下，降维有很大帮助。

提升算法

术语“提升”是指将弱学习者转变为强学习者的一系列算法。 让我们通过解决垃圾邮件识别问题来理解这个定义，如下所示 -

将电子邮件分类为垃圾邮件应该遵循什么程序？ 在最初的方法中，我们会使用以下标准识别“垃圾邮件”和“非垃圾邮件”电子邮件，如果 -

• 电子邮件只有一个图像文件（广告图像），它是一个垃圾邮件

• 电子邮件只有链接，这是垃圾邮件

• 电子邮件正文包含“你赢得了$ xxxxxx奖金”之类的句子，这是一个垃圾邮件

• 来自我们官方域名“iowiki.com”的电子邮件，而不是垃圾邮件

• 来自已知来源的电子邮件，而不是垃圾邮件

上面，我们已经定义了几个规则来将电子邮件分类为“垃圾邮件”或“非垃圾邮件”。 但是，这些规则个别不足以成功将电子邮件分类为“垃圾邮件”或“非垃圾邮件”。 因此，这些规则被称为weak learner 。

为了将弱学习者转变为强学习者，我们使用以下方法将每个弱学习者的预测结合起来 -

• 使用平均/加权平均值
• 考虑到投票率较高的预测

例如，假设我们已经定义了7个弱学习者。 在这7个中，有5个被评为“垃圾邮件”，2个投票为“非垃圾邮件”。 在这种情况下，默认情况下，我们会将电子邮件视为垃圾邮件，因为我们对“垃圾邮件”的投票率较高（5）。

它是如何工作的 (How It Works)

提升将弱学习者或基础学习者结合起来形成一个强有力的规则。 本节将向您解释增强功能如何识别弱规则。

为了找到弱规则，我们应用具有不同分布的基础学习（ML）算法。 每次应用基础学习算法时，它都会生成一个新的弱预测规则。 这几次使用迭代过程。 在多次迭代之后，增强算法将这些弱规则组合成单个强预测规则。

要为每轮选择正确的分布，请按照给定的步骤 -

Step 1 - 基础学习者获取所有分布并为每个分配赋予相同的权重。

Step 2 - 如果存在由第一基础学习算法引起的任何预测误差，则我们对具有预测误差的观测值支付更高的权重。 然后，我们应用下一个基础学习算法。

我们迭代步骤2，直到达到基本学习算法的极限或达到更高的精度。

最后，它结合了弱学习者的输出，并形成了一个强大的学习者，最终提高了模型的预测能力。 提升更多地关注由于规则较弱而被错误分类或具有较高错误的示例。

Boosting算法的类型

有几种类型的引擎用于提升算法 - 决策残余，边际最大化分类算法等。 这里列出了不同的增强算法 -

• AdaBoost（自适应提升）
• 渐变树提升
• XGBoost

本节重点介绍AdaBoost和Gradient Boosting，然后是各自的Boosting算法。

AdaBoost

请注意下图解释Ada-boost算法。

它解释如下 -

Box 1 - 您可以看到我们为每个数据点分配了相同的权重，并应用了决策树桩将它们分类为+（ plus ）或 - （ minus ）。 决策树桩（D1）在左侧创建了一条垂直线来对数据点进行分类。 此垂直线错误地预测三个+（加号）为 - （减号）。 因此，我们将为这三个+（加号）分配更高的权重，并应用另一个决策树桩。

Box 2 - 在这里，可以看出，与其他数据点相比，三个（错误预测的）+（ plus ）数据点的大小更大。 在这种情况下，第二个决策树桩（D2）将尝试正确预测它们。 现在，此框右侧的垂直线（D2）已正确分类三个错误分类+（ plus ）。 但同样，它也犯了错误的分类错误。 这次有三个（ minus ）数据点。 同样，我们将为三个（ minus ）数据点分配更高的权重，并应用另一个决策树桩。

Box 3 - 这里，三（ - minus ）数据点的权重更高。 应用决策残端（D3）来正确预测这些错误分类的观察结果。 这次生成水平线以基于错误分类的观察的较高权重对+（ plus ）和 - （ minus ）数据点进行分类。

Box 4 - 在这里，我们加入了D1，D2和D3，形成了一个强有力的预测，与单个弱学习者相比，具有复杂的规则。 可以看出，与任何个体弱学习者相比，该算法对这些观察结果进行了很好的分类。

AdaBoost or Adaptive Boosting - 它的工作方式与上面讨论的类似。 它适合不同加权训练数据的弱学习者序列。 它首先预测原始数据集，并给予每次观察相同的权重。 如果使用第一个学习者进行预测不正确，那么它对不正确预测的观察结果给予更高的权重。 作为一个迭代过程，它继续添加学习者，直到达到模型数量或准确度的限制。

大多数情况下，我们使用AdaBoost决策标记。 但是，如果它接受训练数据集的权重，我们可以使用任何机器学习算法作为基础学习器。 我们可以将AdaBoost算法用于分类和回归问题。

您可以使用以下Python代码来实现此目的 -

#for classification
from sklearn.ensemble import AdaBoostClassifier
#for regression
from sklearn.ensemble import AdaBoostRegressor
from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier()
clf = AdaBoostClassifier(n_estimators=100, base_estimator=dt,learning_rate=1)
#Here we have used decision tree as a base estimator; Any ML learner can be used as base #estimator if it accepts sample weight
clf.fit(x_train,y_train)

调整参数

可以调整参数以优化算法的性能。调整的关键参数是 -

n_estimators - 它们控制弱学习者的数量。

learning_rate - 它控制弱学习者在最终组合中的贡献。 在learning_rate和n_estimators之间进行权衡。

base_estimators - 这些有助于指定不同的ML算法。

还可以调整基础学习者的参数以优化其性能。

渐变提升

在梯度增强中，许多模型被顺序训练。 每个新模型使用梯度下降法逐渐最小化整个系统的损失函数（y = ax + b + e，其中'e'是误差项）。 学习方法连续适合新模型，以更准确地估计响应变量。

该算法背后的主要思想是构建新的基础学习器，其可以与损失函数的负梯度最佳地相关，与整个集合相关。

在Python Sklearn库中，我们使用Gradient Tree Boosting或GBRT，这是对任意可微分损失函数的推广的推广。 它可以用于回归和分类问题。

您可以使用以下代码来实现此目的 -

#for classification
from sklearn.ensemble import GradientBoostingClassifier
#for regression
from sklearn.ensemble import GradientBoostingRegressor
clf = GradientBoostingClassifier(n_estimators = 100, learning_rate = 1.0, max_depth = 1)
clf.fit(X_train, y_train)

以下是上述代码中使用的术语 -

n_estimators - 它们控制弱学习者的数量。

learning_rate - 它控制弱学习者在最终组合中的贡献。 在learning_rate和n_estimators之间进行权衡。

max_depth - 这是限制树中节点数的各个回归估计器的最大深度。 调整此参数以获得最佳性能，最佳值取决于输入变量的交互。

可以调整损耗函数以获得更好的性能。

Machine Learning with Python - Applications

人工智能（AI）和机器学习无处不在。 您可能正在使用它们，甚至没有意识到这一点。 在机器学习（ML）中，计算机，软件和设备通过类似于人类大脑的认知来执行。

机器学习的典型成功应用包括解码手写文本，人脸识别，语音识别，语音识别，模式识别，垃圾邮件检测程序，天气预报，股票市场分析和预测等的程序。 本章详细讨论了这些应用程序。

虚拟个人助理

Siri，Google Now，Alexa是虚拟个人助理的一些常见例子。 当通过语音询问时，这些应用程序有助于查找信息。 所需要的只是激活它们并提出诸如“我今天的约会是什么？”，“从德里到纽约的航班是什么”等问题。 为了回答此类查询，应用程序会查找信息，回忆您之前的查询，并访问其他资源以收集相关信息。 您甚至可以告诉这些助手执行某些任务，例如“第二天早上5点30分设置闹钟”，“提醒我明天上午10点30分访问护照办公室”。

交通拥堵分析与预测

GPS导航服务监控用户的位置和速度，并使用它们来构建当前流量的地图。 这有助于防止交通拥堵。 在这种情况下的机器学习有助于基于先前的记录来估计可以找到拥塞的区域。

自动视频监控

如今的视频监控系统由人工智能提供支持，机器学习就是这背后的技术，可以在犯罪发生之前对其进行检测和预防。 他们追踪人们的奇怪和可疑行为，并向最终帮助发生事故和犯罪的人员发出警报。

社交媒体

Facebook会持续监控您与之建立联系的朋友，您的兴趣，工作场所或与您共享的群组等。基于持续学习，Facebook用户列表将作为朋友建议。

人脸识别

你上传了一张你和朋友的照片，Facebook立即认出那位朋友。 机器学习是计算机视觉的核心，计算机视觉是一种从图像和视频中提取有用信息的技术。 Pinterest使用计算机视觉来识别图像中的对象或引脚，并向其用户推荐类似的引脚。

电子邮件垃圾邮件和恶意软件过滤

机器学习正广泛用于垃圾邮件检测和恶意软件过滤，此类垃圾邮件和恶意软件的数据库不断更新，以便有效地处理这些问题。

在线客户支持

在当今的几个网站中，当用户浏览网站时，可以选择与客户支持代表聊天。 在大多数情况下，您不是真正的执行官，而是与聊天机器人交谈。 这些机器人从网站上提取信息并提供给客户以协助他们。 在一段时间内，聊天机器人学会更好地理解用户查询并为他们提供更好的答案，这可以通过机器学习算法实现。

优化搜索引擎结果

谷歌和类似的搜索引擎正在使用机器学习来改善其用户的搜索结果。 每次执行搜索时，后端的算法都会监视用户如何响应结果。 根据用户的响应，在后端工作的算法可以改善搜索结果。

产品推荐

如果用户在线购买或搜索产品，他/她将继续收到有关该产品的购物建议和广告的电子邮件。 基于先前的用户行为，在网站/应用，过去购买，喜欢或添加到购物车的项目，品牌偏好等，产品推荐被发送给用户。

检测在线欺诈

机器学习用于在线跟踪货币欺诈。 例如 - Paypal使用ML来防止洗钱。 该公司正在使用一套工具，帮助他们比较数百万笔交易，并区分买卖双方之间发生的合法或非法交易。