Machine Learning With Python 简明教程

Machine Learning With Python - Quick Guide

Machine Learning with Python - Basics

我们生活在“数据时代”，该时代拥有更强大的计算能力和更多的存储资源。这些数据或信息正在与日俱增，但真正的挑战在于理解所有这些数据。企业和组织正试图通过使用数据科学、数据挖掘和机器学习中的概念和方法来构建智能系统以此来解决问题。其中，机器学习是计算机科学中最令人兴奋的领域。如果我们称机器学习是提供数据意义的算法的应用和科学，那并不会有错。

What is Machine Learning?

机器学习 (ML) 是计算机科学的一个领域，借助该领域，计算机系统能够像人类一样赋予数据意义。

简单来说，机器学习是一种人工智能，它通过使用算法或方法从原始数据中提取模式。机器学习的主要重点是让计算机系统在没有明确编程或人为干预的情况下从经验中学习。

Need for Machine Learning

就目前而言，人类是地球上最聪明、最先进的物种，因为他们可以思考、评估和解决复杂的问题。另一方面，人工智能仍处于起步阶段，在许多方面尚未超越人类的智慧。那么问题是为什么要让机器学习？这样做的最恰当理由是“高效、大规模地基于数据做出决策”。

最近，企业在人工智能、机器学习和深度学习等较新技术上投入巨资，从数据中获取关键信息执行若干实战任务并解决问题。我们可以称之为机器采取的数据驱动型决策，特别是为了自动化此流程。数据驱动型决策可以用来解决无法固有地编程的问题，代替使用程序设计逻辑。事实是，我们离不开人类智能，但另一方面是我们所有人都需要高效、大规模地解决现实世界问题。这就是机器学习需求存在的原因。

Why & When to Make Machines Learn?

我们已经讨论了机器学习的必要性，但另一个问题出现了，即在什么情况下我们必须让机器学习？机器需要高效且大规模地进行数据驱动决策的情况可能有多种。以下是机器学习更有效的一些情况−

Lack of human expertise

第一个我们希望机器学习并做出数据驱动决策的情况可能是缺乏人类专业知识的领域。示例可以是未知领域或空间行星的导航。

Dynamic scenarios

有些情况本质上是动态的，即它们会随着时间的推移而不断变化。对于这些情况和行为，我们希望机器学习并做出数据驱动决策。一些示例可以是网络连接和组织中基础设施的可用性。

Difficulty in translating expertise into computational tasks

人类可能在各个领域拥有专业知识；但是，他们无法将此专业知识转化为计算任务。在这种情况下，我们需要机器学习。示例可以是语音识别、认知任务等领域。

Machine Learning Model

在讨论机器学习模型之前，我们需要了解米切尔教授给出的以下 ML 正式定义：

“如果计算机程序相对于某些类别的任务 T 和性能衡量标准 P 从经验 E 中学习，那么根据 P 衡量，它在 T 中的任务的性能会通过经验 E 而提高。”

上面的定义主要关注三个参数，也是任何学习算法的主要组成部分，即任务（T）、性能（P）和经验（E）。在这种情况下，我们可以将此定义简化为−

机器学习是包括学习算法的人工智能领域，其中包含：

Improve their performance (P)
在执行某个任务 (T) 时
随着时间的推移和经验 (E)

基于上述内容，以下图表表示一个机器学习模型−

现在让我们更详细地讨论它们−

Task(T)

从问题的角度来看，我们可以将任务 T 定义为要解决的现实世界问题。该问题可以是找到特定位置的最佳房屋价格或找到最佳营销策略等。另一方面，如果我们谈论机器学习，任务的定义是不同的，因为很难通过传统编程方法解决基于机器学习的任务。

任务 T 被称为基于机器学习的任务，当它基于数据点进行操作必须遵循的过程和系统时。基于机器学习的任务的示例包括分类、回归、结构化注释、聚类、转录等。

Experience (E)

顾名思义，它是从提供给算法或模型的数据点中获得的知识。一旦提供了数据集，模型将迭代运行并会学习一些固有模式。由此获得的学习称为经验（E）。与人类学习进行类比，我们可以将这种情况视为一个人从情况、关系等各种属性中学习或获得一些经验的情况。监督学习、无监督学习和强化学习是学习或获得经验的一些方法。我们的机器学习模型或算法获得的经验将用于解决任务 T。

Performance (P)

机器学习算法应该随着时间的推移执行任务并获得经验。衡量机器学习算法是否按预期执行的衡量标准是其性能 (P)。P 基本上是一个定量指标，它告诉模型如何使用其经验 E 执行任务 T。有许多指标有助于理解机器学习性能，例如准确性得分、F1 分数、混淆矩阵、精确度、召回率、灵敏度等。

Challenges in Machines Learning

尽管机器学习正在快速发展，在网络安全和自动驾驶汽车领域取得重大进展，但作为整体而言的 AI 的这一部分还有很长的路要走。其原因在于机器学习未能克服许多挑战。机器学习目前面临的挑战有：

Quality of data − 拥有高质量数据以用于机器学习算法是最大的挑战之一。使用低质量数据会导致与数据预处理和特征提取相关的难题。

Time-Consuming task − 机器学习模型面临的另一个挑战是消耗很多时间，尤其是在数据获取、特征提取和检索上。

Lack of specialist persons − 鉴于机器学习技术仍处于初级阶段，因此获得专家资源是一项艰巨的任务。

No clear objective for formulating business problems − 没有清晰的目标和明确定义的业务问题是对采用机器学习的另一个关键挑战，因为此技术尚未成熟。

Issue of overfitting & underfitting − 如果模型出现过拟合或欠拟合，则无法很好地表示该问题。

Curse of dimensionality − 机器学习模型面临的另一个挑战是拥有过多的数据点特征。这会成为真正的障碍。

Difficulty in deployment − 机器学习模型的复杂性使其难以在现实生活中部署。

Applications of Machines Learning

机器学习是发展最快的技术，根据研究人员的说法，我们正处于人工智能和机器学习的黄金时代。它用来解决许多无法使用传统方法解决的现实世界中的复杂问题。以下是机器学习的一些实际应用：

Emotion analysis
Sentiment analysis
Error detection and prevention
Weather forecasting and prediction
股票市场分析和预测
Speech synthesis
Speech recognition
Customer segmentation
Object recognition
Fraud detection
Fraud prevention
向网上购物的客户推荐产品。

Machine Learning with Python - Ecosystem

An Introduction to Python

Python 是一种流行的面向对象编程语言，具有高级编程语言的功能。它易于学习的语法和可移植性使其在当下变得很流行。以下事实为我们介绍了 Python：

Python 由荷兰数学和计算机科学研究中心（Stichting Mathematisch Centrum）的 Guido van Rossum 开发。
它编写为名为“ABC”的编程语言的后继语言。
它的第一个版本于 1991 年发布。
Python 这个名字由 Guido van Rossum 从名为《蒙提·派森的飞行马戏团》的电视节目中选出。
它是一种开源编程语言，这意味着我们可以免费下载并使用它开发程序。它可以从 www.python.org 下载。
Python 编程语言同时具有 Java 和 C 的特性。它具有优雅的“C”代码，另一方面，它拥有类和对象，如 Java 用于面向对象编程。
它是一种解释型语言，这意味着 Python 程序的源代码将首先转换为字节码，然后由 Python 虚拟机执行。

Strengths and Weaknesses of Python

每种编程语言都有一些优点和缺点，Python 也如此。

Strengths

根据研究和调查，Python 是第五大最重要语言，也是机器学习和数据科学中最流行的语言。这是因为 Python 具有以下优势：

Easy to learn and understand ：Python 语法更简单；因此，即使是初学者也相对容易学习和理解该语言。

Multi-purpose language ：Python 是一种多用途编程语言，因为它支持结构化编程、面向对象编程以及函数式编程。

Huge number of modules ：Python 拥有大量模块，涵盖了编程的各个方面。这些模块很容易使用，因此使 Python 成为一种可扩展的语言。

Support of open source community ：作为开源编程语言，Python 得到非常庞大的开发人员社区的支持。因此，Python 社区可以轻松修复 bug。此特性使 Python 非常强大且具有适应性。

Scalability ：Python 是一种可扩展编程语言，因为它提供了比 shell 脚本更好的支持大型程序的结构。

Weakness

尽管 Python是一种流行且功能强大的编程语言，但它也有自己的弱点，即执行速度慢。

与编译型语言相比，Python 的执行速度较慢，因为 Python 是一种解释型语言。这可能是 Python 社区的主要改进领域。

Installing Python

要使用 Python，我们必须先安装它。你可以使用以下两种方法之一来安装 Python：

Installing Python individually
使用预打包的 Python 发行版：Anaconda

让我们详细讨论每一个。

Installing Python Individually

如果你想在计算机上安装 Python，则只需为你所在的平台下载适用的二进制代码即可。Python 发行版适用于 Windows、Linux 和 Mac 平台。

以下是上述平台上安装 Python 的快速概述：

On Unix and Linux platform

通过以下步骤，我们可以在 Unix 和 Linux 平台上安装 Python −

First, go to https://www.python.org/downloads/.
接下来，单击链接以下载适用于 Unix/Linux 的存档源代码。
现在，下载并解压文件。
接下来，如果想自定义一些选项，可以编辑 Modules/Setup 文件。接下来，编写以下命令运行 ./configure 脚本使之安装

On Windows platform

借助以下步骤，我们可以在 Windows 平台上安装 Python：

First, go to https://www.python.org/downloads/.
接下来，单击 Windows 安装程序 python-XYZ.msi 文件的链接。其中 XYZ 是我们要安装的版本。
现在，我们必须运行已下载的文件。它将带我们进入 Python 安装向导，它很容易使用。现在，接受默认设置并等到安装完成。

On Macintosh platform

对于 Mac OS X，建议使用 Homebrew，一个易于使用的软件包安装程序来安装 Python 3。如果你没有 Homebrew，可以使用以下命令安装：

$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"

可以使用以下命令更新：

$ brew update

现在，要在你的系统上安装 Python3，我们需要运行以下命令：

$ brew install python3

Using Pre-packaged Python Distribution: Anaconda

Anaconda 是 Python 的一个打包编译，它具有在数据科学中广泛使用的所有库。我们可以按照以下步骤使用 Anaconda 设置 Python 环境：

Step1 − 首先，我们需要从 Anaconda 发行版下载所需的安装包。其链接为 [role="bare"] [role="bare"]https://www.anaconda.com/products/individualhttps://www.anaconda.com/distribution/ 。你可以根据需要选择 Windows、Mac 和 Linux 操作系统。

Step2 − 接下来，选择想要在电脑上安装的 Python 版本。最新 Python 版本是 3.7。在那里，你将获得适用于 64 位和 32 位图形化安装程序的选项。

Step3 − 选择了操作系统和 Python 版本之后，它将在电脑上下载 Anaconda 安装程序。现在，双击该文件，安装程序将安装 Anaconda 包。

Step4 − 如要检查是否已安装，请打开命令提示符，然后键入以下 Python：

你还可以通过 https://www.tutorialspoint.com/python_essentials_online_training/getting_started_with_anaconda.asp 观看详细视频讲座来检查这一点。

Why Python for Data Science?

Python 是机器学习和数据科学中最流行的语言，重要性排名第五。以下是 Python 的特性，使其成为数据科学的首选语言：

Extensive set of packages

Python 拥有一套广泛而强大的可用在不同领域的包。它还具有 numpy、scipy、pandas、scikit-learn 等机器学习和数据科学所需的包。

Easy prototyping

Python 的另一个重要特性使其成为数据科学语言首选，那就是轻松而快速的原型制作。该特性对于开发新算法非常有用。

Collaboration feature

数据科学领域基本上需要良好的协作，而 Python 提供了许多有用的工具，极大地促进了协作。

One language for many domains

典型的数据科学项目包括各个领域，如数据提取、数据处理、数据分析、特征提取、建模、评估、部署和更新解决方案。由于 Python 是一种多用途语言，它允许数据科学家从一个通用平台来处理所有这些领域。

Components of Python ML Ecosystem

在本部分，我们将讨论构成 Python 机器学习生态系统组件的一些核心数据科学库。这些有用的组件使 Python 成为数据科学的重要语言。尽管有许多这样的组件，但让我们在此讨论 Python 生态系统中的一些重要组件：

Jupyter Notebook

Jupyter 笔记本基本上提供了一个交互式计算环境，用于开发基于 Python 的数据科学应用程序。它们以前称为 iPython 笔记本。以下是 Jupyter 笔记本的一些特性，使其成为 Python ML 生态系统最佳组件之一 −

Jupyter 笔记本可以通过逐步排列代码、图像、文本、输出等内容，逐步展示分析过程。
它有助于数据科学家在开发分析过程时记录其思路。
人们还可以将结果记录为该笔记本的一部分。
借助 Jupyter 笔记本，我们还可以与同行分享我们的工作。

Installation and Execution

如果你使用的是 Anaconda 发行版，那么你无需单独安装 Jupyter 笔记本，因为它已随附安装。你只需转到 Anaconda Prompt 并键入以下命令 −

C:\>jupyter notebook

按 Enter 后，它将在计算机的 localhost:8888 上启动一个笔记本服务器。它显示在以下屏幕截图中 −

现在，在单击新选项卡后，你会得到一个选项列表。选择 Python 3，它将带你到新笔记本中开始工作。你可以在以下屏幕截图中看到它的预览 −

另一方面，如果你使用的是标准 Python 发行版，则可以使用流行的 Python 软件包安装程序 pip 安装 Jupyter 笔记本。

pip install jupyter

Types of Cells in Jupyter Notebook

以下是 Jupyter 笔记本中的三种类型的单元格 −

Code cells − 顾名思义，我们可以使用这些单元格编写代码。在编写完代码/内容后，它会将其发送到与该笔记本关联的内核。

Markdown cells − 我们可以使用这些单元格来记录计算过程。它们可以包含诸如文本、图像、Latex 方程式、HTML 标签等内容。

Raw cells − 其中编写的文本按原样显示。这些单元格基本上用于添加我们不希望被 Jupyter 笔记本的自动转换机制转换的文本。

如需详细了解 jupyter notebook，你可以访问此链接 https://www.tutorialspoint.com/jupyter/index.htm 。

NumPy

这是使 Python 成为了最受数据科学领域欢迎的语言之一的另一有用组件。它实际上代表的是 Numerical Python，由多维数组对象构成。通过使用 NumPy，我们可以执行以下重要操作：

数组上的数学和逻辑运算。
Fourier transformation
与线性代数相关的运算。

我们也可以将 NumPy 看作是 MatLab 的替代品，因为 NumPy 主要会和 Scipy（科学 Python）和 Mat-plotlib（绘图库）一起使用。

Installation and Execution

如果你正在使用 Anaconda 发行版，则无需单独安装 NumPy，因为它已经随发行版一起安装。你只需使用以下方式将该程序包导入到 Python 脚本中即可−

import numpy as np

另一方面，如果你正在使用标准 Python 发行版，则可以使用流行的 python 程序包安装程序 pip 安装 NumPy。

pip install NumPy

如需详细了解 NumPy，你可以访问此链接 https://www.tutorialspoint.com/numpy/index.htm 。

Pandas

这是使 Python 成为数据科学首选语言之一的另一个有用 Python 库。Pandas 主要用于数据操作、清理和分析。它由韦斯·麦金尼于 2008 年开发。在数据处理时，借助 Pandas，我们可以完成以下五个步骤：

Load
Prepare
Manipulate
Model
Analyze

Data representation in Pandas

数据在 Pandas 中的整个表示形式借助以下三个数据结构完成：

Series − 它实际上是一个具有一维 axis 标签的 ndarray，这意味着它类似于一个具有同类数据的简单数组。举例来说，下面的序列是数字 1、5、10、15、24、25 的集合…

Data frame − 这是最实用的数据结构，用于 pandas 中几乎所有类型的表示和数据操作。它实际上是一个可以包含异类数据的二维数据结构。通常，使用数据框架表示表格数据。举例来说，下面表格显示了姓名和学号、年龄和性别等学生数据：

Name
Roll number
Age
Gender
Aarav
1
15
Male
Harshit
2
14
Male
Kanika
3
16
Female
Mayank
4
15
Male

Panel − 它是一个包含异构数据的三维数据结构。以图形方式表示框架非常困难，但可以将其视为 DataFrame 的容器。

下表为 Pandas 中上述数据结构提供了尺寸和说明：

Data Structure

Dimension

Description

Series

1-D

大小不可变，一维同质数据

DataFrames

2-D

大小可变，表格形式的异构数据

Panel

3-D

大小可变的数组，DataFrame 的容器。

我们可以理解，高维数据结构是低维数据结构的容器。

Installation and Execution

如果你使用 Anaconda 发行版，则无需单独安装 Pandas，因为它已随此发行版安装。你只需要使用以下命令将其导入 Python 脚本中 −

import pandas as pd

另一方面，如果你使用的是标准 Python 发行版，则可以使用流行的 python 软件包安装程序 pip 安装 Pandas。

pip install Pandas

安装 Pandas 后，您可以将其导入 Python 脚本，如上所述。

Example

以下是使用 Pandas 从 ndarray 创建一个系列的示例 −

In [1]: import pandas as pd

In [2]: import numpy as np

In [3]: data = np.array(['g','a','u','r','a','v'])

In [4]: s = pd.Series(data)

In [5]: print (s)

0 g
1 a
2 u
3 r
4 a
5 v

dtype: object

有关 Pandas 的更详细研究，你可以访问 https://www.tutorialspoint.com/python_pandas/index.htm 链接。

Scikit-learn

另一个有用且最重要的 python 库是 Scikit-learn，用于 Python 中的数据科学和机器学习。以下是 Scikit-learn 的一些使其如此有用的功能 −

它建立在 NumPy、SciPy 和 Matplotlib 上。
它是一个开源库，可以在 BSD 许可下重复使用。
它可供所有人使用，并且可以在各种环境中重复使用。
广泛的机器学习算法涵盖机器学习的主要领域，如分类、聚类、回归、降维、模型选择等，它们可以在它的帮助下得到实现。

Installation and Execution

如果你使用 Anaconda 发行版，则无需单独安装 Scikit-learn，因为它已随其一同安装。你只需要在 Python 脚本中使用包即可。例如，通过以下脚本行，我们从 Scikit-learn 导入乳腺癌患者的数据集 −

from sklearn.datasets import load_breast_cancer

另一方面，如果你使用标准 Python 发行版并拥有 NumPy 和 SciPy，则可以使用流行的 python 包安装器 pip 来安装 Scikit-learn。

pip install -U scikit-learn

安装 Scikit-learn 后，你可以将其用在 Python 脚本中，正如你上面所做的那样。

Machine Learning with Python - Methods

有各种 ML 算法、技术和方法可用于通过使用数据构建用于解决现实问题的模型。在本章中，我们将讨论这些不同种类的研究方法。

Different Types of Methods

以下是基于一些广泛类别的各种 ML 研究方法 −

Based on human supervision

在学习过程中，一些基于人工监督的方法如下 −

Supervised Learning

监督学习算法或方法是最常用的 ML 算法。此方法或学习算法在训练过程中获取数据样本，即训练数据及其相关输出，即每个数据样本的标签或响应。

监督学习算法的主要目的是在执行多个训练数据实例后，学习输入数据样本与相应输出之间的关联。

例如，我们有

x：输入变量和

y：输出变量

现在，应用算法从输入到输出学习映射函数，如下所示：

Y=f(x)

现在，主要目标是要很好地逼近映射函数，即使我们有新的输入数据 (x)，我们也能轻松预测该新输入数据的输出变量 (Y)。

我们称之为监督，因为整个学习过程可以理解为它是由老师或主管监督的。监督机器学习算法的示例包括 Decision tree, Random Forest, KNN, Logistic Regression 等。

根据 ML 任务，监督学习算法可以分为以下两大类 −

Classification
Regression

Classification

基于分类的任务的关键目标是预测给定输入数据的类别输出标签或响应。输出将基于模型在训练阶段中学到的内容。众所周知，类别输出响应是指无序的不连续值，因此每个输出响应都将属于一个特定类别。我们还将在即将到来的章节中详细讨论分类和相关算法。

Regression

基于回归的任务的关键目标是为给定的输入数据预测输出标签或响应，这些标签或响应是连续数值。输出将基于模型在其训练阶段中学习到的结果。基本上，回归模型使用输入数据特征（自变量）及其相应的连续数值输出值（因变量或结果变量）来学习输入与相应输出之间的特定关联。我们还将在后面的章节中详细讨论回归和相关算法。

Unsupervised Learning

顾名思义，它与监督式 ML 方法或算法相反，这意味着在无监督机器学习算法中，我们没有任何主管提供任何形式的指导。无监督学习算法在没有自由度的情况下很方便，例如在监督学习算法中拥有预先标记的训练数据，并且我们希望从输入数据中提取有用的模式。

例如，它可以理解如下：

假设我们有 -

{s1}，那么将没有相对应的输出变量，并且算法需要发现数据中有趣的模式以进行学习。

无监督机器学习算法的示例包括 K 均值聚类，{s2} 等。

根据 ML 任务，无监督学习算法可以分为以下广泛类别 −

Clustering
Association
Dimensionality Reduction

Clustering

聚类方法是最有用的无监督 ML 方法之一。这些算法用于查找数据样本的相似性和关系模式，然后将这些样本聚类到具有基于特征的相似性的组中。聚类的实际示例是按购买行为对客户进行分组。

Association

另一种有用的无监督 ML 方法是 {s3}，它用于分析大体数据集以查找进一步表示不同项目之间的有趣关系的模式。它也称为 {s4} 或 {s5}，主要用于分析客户购物模式。

Dimensionality Reduction

此无监督 ML 方法通过选择代表性特征或主要特征集，用于减少每个数据样本的特征变量数量。这里产生一个问题，即我们为什么要减少维数？背后的原因是特征空间复杂性的问题，该问题在我们开始分析和从数据样本中提取数百万个特征时出现。此问题通常称为“维数灾难”。主成分分析 (PCA)、K 近邻和判别分析是用于此目的的部分流行算法。

Anomaly Detection

此无监督 ML 方法用于找出通常不会发生的罕见事件或观测的发生。通过使用学到的知识，异常检测方法将能够区分异常数据点或正常数据点。诸如聚类、KNN 等部分无监督算法可以基于数据及其特征检测异常。

Semi-supervised Learning

此类算法或方法既不完全受监督，也不完全不受监督。它们基本上介于两种方法之间，即监督和无监督学习方法。这类算法通常使用较小的监督学习组件，即少量预标记注释数据和大量的无监督学习组件，即大量未标记数据进行训练。我们可以遵循以下任何一种方法来实现半监督学习方法：

第一个且简单的方法是基于少量标记和带注释数据构建有监督模型，然后将相同的模型应用于大量未标记数据来构建无监督模型以获得更多的标记样本。现在，在它们上训练模型并重复该过程。
第二个方法需要一些额外的努力。在此方法中，我们首先可以使用无监督方法对类似的数据样本进行聚类，注释这些组，然后使用这些信息的组合来训练模型。

Reinforcement Learning

这些方法不同于以前的研究方法，使用也很少。在这种类型的学习算法中，有一个代理，我们希望在一段时间内对它进行训练，以便它可以与特定环境交互。该代理将遵循一组与环境交互的策略，然后在观察环境后，将针对环境的当前状态采取行动。以下是强化学习方法的主要步骤：

Step1 ——首先，我们需要准备一个具有某些初始策略集的代理。
Step2 ——然后观察环境及其当前状态。
Step3 ——接下来，选择与环境当前状态相关的最佳策略并执行重要操作。
Step4 ——现在，该代理可以根据它在上一步中采取的操作获得相应的奖励或惩罚。
Step5 ——现在，我们可以更新策略，如果需要的话。
Step6 ——最后，重复步骤 2-5，直至代理学会并采用最佳策略。

Tasks Suited for Machine Learning

下图显示了哪种类型的任务适合各种机器学习问题：

Based on learning ability

在学习过程中，以下是基于学习能力的一些方法：

Batch Learning

在很多情况下，我们有端到端的机器学习系统，我们需要一次性使用所有可用的训练数据来训练模型。这种学习方法或算法称为 {s11}。它被称为批量或离线学习，因为它是一次性过程，模型将使用一个批次中的数据进行训练。以下是批量学习方法的主要步骤：

Step1 ——首先，我们需要收集所有训练数据以开始训练模型。

Step2 ——现在，通过一次性提供整个训练数据来开始模型训练。

Step3 ——然后，一旦您获得令人满意的结果/表现，就停止学习/训练过程。

Step4 − 最后，将此训练模型部署到生产中。在此情况下，它将预测新数据样本的输出。

Online Learning

它与批量或离线学习方法完全相反。在这些学习方法中，训练数据以多个递增批次（称为小批次）提供给算法。以下是在线学习方法的主要步骤 −

Step1 − 首先，我们需要收集所有训练数据用于开始训练模型。

Step2 − 现在，通过向算法提供小批量的训练数据，开始训练模型。

Step3 − 接下来，我们需要以多个增量向算法提供小批量的训练数据。

Step4 − 由于它不会像批量学习那样停止，因此在以小批次提供整个训练数据之后，还要向它提供新的数据样本。

Step5 − 最后，它将根据新数据样本在一段时间内持续学习。

Based on Generalization Approach

在学习过程中，以下是一些基于泛化方法的方法 −

Instance based Learning

基于实例的学习方法是一种有用的方法，它通过对输入数据进行泛化来构建机器学习模型。它与之前研究过的学习方法相反，这种学习涉及机器学习系统以及使用原始数据点本身为较新的数据样本绘制结果而不基于训练数据构建显式模型的方法。

简单来说，基于实例的学习基本上从查看输入数据点开始，然后使用相似性度量对新数据点进行泛化和预测。

Model based Learning

在基于模型的学习方法中，迭代过程发生在基于各种模型参数（称为超参数）构建的机器学习模型上，其中输入数据用于提取特征。在这个学习中，基于各种模型验证技术优化超参数。这就是为什么我们可以说基于模型的学习方法对泛化使用更传统的机器学习方法。

Data Loading for ML Projects

假设你想启动一个机器学习项目，那么你需要的第一个也是最重要的事情是什么？它就是我们需要加载用于开始任何机器学习项目的 data。关于数据，机器学习项目中最常见的数据格式是 CSV（逗号分隔值）。

基本上，CSV 是一种简单文件格式，用于存储制表数据（数字和文本），如纯文本中的电子表格。在 Python 中，我们可以用不同的方式加载 CSV 数据，但在加载 CSV 数据之前，我们必须考虑一些注意事项。

Consideration While Loading CSV data

CSV 数据格式是机器学习数据最常见的格式，但在将其加载到我们的机器学习项目中时，我们需要考虑以下主要注意事项 −

File Header

在 CSV 数据文件中，标题包含每个字段的信息。我们必须对标题文件和数据文件使用相同的定界符，因为标题文件指定了如何解释数据字段。

以下是必须考虑的与 CSV 文件标题相关的两个案例 −

Case-I: When Data file is having a file header − 如果数据文件有文件标题，它将自动为每列数据分配名称。
Case-II: When Data file is not having a file header − 如果数据文件没有文件标题，我们需要手动为每列数据分配名称。

在这两种情况下，我们都必须明确指定我们的 CSV 文件是否包含标题。

Comments

任何数据文件中的注释都有其重要意义。在 CSV 数据文件中，注释由行首的井号 (#) 表示。在将 CSV 数据加载到机器学习项目时，我们需要考虑注释，因为如果文件中有注释，则我们可能需要指示（取决于用于加载的方法），是否需要那些注释。

Delimiter

在 CSV 数据文件中，逗号 (,) 字符是标准分隔符。分隔符的作用是分隔字段中的值。在将 CSV 文件上传到机器学习项目时，考虑分隔符的作用很重要，因为我们还可以使用其他分隔符，例如制表符或空格。但是，在使用与标准分隔符不同的分隔符时，我们必须明确指定它。

Quotes

在 CSV 数据文件中，双引号 (“ ”) 标记是默认引号字符。在将 CSV 文件上传到机器学习项目时，考虑引号的作用很重要，因为我们还可以使用双引号标记以外的其他引号字符。但是，在使用与标准引号字符不同的引号字符时，我们必须明确指定它。

Methods to Load CSV Data File

在使用机器学习项目时，最关键的任务是正确地将数据加载到其中。机器学习项目最常用的数据格式是 CSV，并且它具有多种风味和不同的解析难度。在本节中，我们将讨论在 Python 中加载 CSV 数据文件的三种常见方法−

Load CSV with Python Standard Library

加载 CSV 数据文件的第一种也是最常用的一种方法是使用 Python 标准库，它为我们提供各种内置模块，即 csv 模块和 reader() 函数。以下是如何在它的帮助下加载 CSV 数据文件的示例−

Example

在这个示例中，我们使用可下载到我们本地目录的鸢尾花数据集。加载数据文件后，我们可以将其转换为 NumPy 数组并将其用于机器学习项目。以下是加载 CSV 数据文件的 Python 脚本−

首先，我们需要如下导入 Python 标准库提供的 csv 模块−

import csv

接下来，我们需要导入 Numpy 模块以将加载的数据转换为 NumPy 数组。

import numpy as np

现在，提供存储在本地目录中且具有 CSV 数据文件的文件的完整路径−

path = r"c:\iris.csv"

接下来，使用 csv.reader() 函数从 CSV 文件中读取数据−

with open(path,'r') as f:
   reader = csv.reader(f,delimiter = ',')
   headers = next(reader)
   data = list(reader)
   data = np.array(data).astype(float)

我们可以使用以下脚本行打印标题的名称−

print(headers)

下一行脚本将打印数据的形状，即文件中的行数和列数−

print(data.shape)

下一行脚本将给出数据文件的头三行−

print(data[:3])

Output

['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
(150, 4)
[  [5.1 3.5 1.4 0.2]
   [4.9 3. 1.4 0.2]
   [4.7 3.2 1.3 0.2]]

Load CSV with NumPy

加载 CSV 数据文件的另一种方法是 NumPy 和 numpy.loadtxt() 函数。以下是如何在它的帮助下加载 CSV 数据文件的示例−

Example

在这个示例中，我们使用包含糖尿病患者数据的皮马印第安人数据集。此数据集是无标头的数字数据集。它也可以下载到我们的本地目录。加载数据文件后，我们可以将其转换为 NumPy 数组并将其用于机器学习项目。以下是加载 CSV 数据文件的 Python 脚本−

from numpy import loadtxt
path = r"C:\pima-indians-diabetes.csv"
datapath= open(path, 'r')
data = loadtxt(datapath, delimiter=",")
print(data.shape)
print(data[:3])

Output

(768, 9)
[  [ 6. 148. 72. 35. 0. 33.6 0.627 50. 1.]
   [ 1. 85. 66. 29. 0. 26.6 0.351 31. 0.]
   [ 8. 183. 64. 0. 0. 23.3 0.672 32. 1.]]

Load CSV with Pandas

加载 CSV 数据文件的另一种方法是 Pandas 和 pandas.read_csv() 函数。这是一个非常灵活的函数，它返回一个 pandas.DataFrame，可以立即用于绘图。以下是如何在它的帮助下加载 CSV 数据文件的示例−

Example

在这里，我们将实现两个 Python 脚本，第一个是具有标题的鸢尾花数据集，另一个是使用皮马印第安人数据集，这是一个无标头的数字数据集。这两个数据集都可以下载到本地目录。

Script-1

以下是使用 Pandas 在鸢尾花数据集上加载 CSV 数据文件的 Python 脚本−

from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.shape)
print(data[:3])

Output:

(150, 4)
   sepal_length   sepal_width  petal_length   petal_width
0         5.1     3.5          1.4            0.2
1         4.9     3.0          1.4            0.2
2         4.7     3.2          1.3            0.2

Script-2

以下是 Python 脚本，用于加载 CSV 数据文件，以及使用 Pandas 对 Pima Indians Diabetes 数据集提供标题名称 -

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
print(data.shape)
print(data[:3])

Output

(768, 9)
   preg  plas  pres   skin  test   mass    pedi    age   class
0   6    148    72      35    0     33.6   0.627    50      1
1   1    85     66      29    0     26.6   0.351    31      0
2   8    183    64      0     0     23.3   0.672    32      1

通过给定的示例，可以轻松理解上述三种用于加载 CSV 数据文件的方法之间的差异。

ML - Understanding Data with Statistics

Introduction

在处理机器学习项目时，我们通常忽略两个最重要的部分，称为 mathematics 和 data 。这是因为，我们知道 ML 是一种数据驱动方法，我们的 ML 模型只会产生与我们提供给它的数据一样好或一样差的结果。

在上一章中，我们讨论了如何将 CSV 数据上传到我们的 ML 项目，但在上传数据之前先了解数据会更好。我们可以通过两种方式理解数据：通过统计数字和通过可视化。

在这一章中，在以下 Python 配方的帮助下，我们将使用统计数据来理解机器学习数据。

Looking at Raw Data

第一个配方是查看原始数据。查看原始数据非常重要，因为查看原始数据后获得的见解将增加我们更好地对机器学习项目的进行数据预处理和处理的机会。

以下是使用 Pandas DataFrame 的 head() 函数在 Pima Indians Diabetes 数据集上实现的 Python 脚本，查看前 50 行以更好地理解它 -

Example

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
print(data.head(50))

Output

preg   plas  pres    skin  test  mass   pedi    age      class
0      6      148     72     35   0     33.6    0.627    50    1
1      1       85     66     29   0     26.6    0.351    31    0
2      8      183     64      0   0     23.3    0.672    32    1
3      1       89     66     23  94     28.1    0.167    21    0
4      0      137     40     35  168    43.1    2.288    33    1
5      5      116     74      0   0     25.6    0.201    30    0
6      3       78     50     32   88    31.0    0.248    26    1
7     10      115      0      0   0     35.3    0.134    29    0
8      2      197     70     45  543    30.5    0.158    53    1
9      8      125     96      0   0     0.0     0.232    54    1
10     4      110     92      0   0     37.6    0.191    30    0
11    10      168     74      0   0     38.0    0.537    34    1
12    10      139     80      0   0     27.1    1.441    57    0
13     1      189     60     23  846    30.1    0.398    59    1
14     5      166     72     19  175    25.8    0.587    51    1
15     7      100      0      0   0     30.0    0.484    32    1
16     0      118     84     47  230    45.8    0.551    31    1
17     7      107     74      0   0     29.6    0.254    31    1
18     1      103     30     38  83     43.3    0.183    33    0
19     1      115     70     30  96     34.6    0.529    32    1
20     3      126     88     41  235    39.3    0.704    27    0
21     8       99     84      0   0     35.4    0.388    50    0
22     7      196     90      0   0     39.8    0.451    41    1
23     9      119     80     35   0     29.0    0.263    29    1
24    11      143     94     33  146    36.6    0.254    51    1
25    10      125     70     26  115    31.1    0.205    41    1
26     7      147     76      0   0     39.4    0.257    43    1
27     1       97     66     15  140    23.2    0.487    22    0
28    13      145     82     19  110    22.2    0.245    57    0
29     5      117     92      0   0     34.1    0.337    38    0
30     5      109     75     26   0     36.0    0.546    60    0
31     3      158     76     36  245    31.6    0.851    28    1
32     3       88     58     11   54    24.8    0.267    22    0
33     6       92     92      0   0     19.9    0.188    28    0
34    10      122     78     31   0     27.6    0.512    45    0
35     4      103     60     33  192    24.0    0.966    33    0
36    11      138     76      0   0     33.2    0.420    35    0
37     9      102     76     37   0     32.9    0.665    46    1
38     2       90     68     42   0     38.2    0.503    27    1
39     4      111     72     47  207    37.1    1.390    56    1
40     3      180     64     25   70    34.0    0.271    26    0
41     7      133     84      0   0     40.2    0.696    37    0
42     7      106     92     18   0     22.7    0.235    48    0
43     9      171    110     24  240    45.4    0.721    54    1
44     7      159     64      0   0     27.4    0.294    40    0
45     0      180     66     39   0     42.0    1.893    25    1
46     1      146     56      0   0     29.7    0.564    29    0
47     2       71     70     27   0     28.0    0.586    22    0
48     7      103     66     32   0     39.1    0.344    31    1
49     7      105      0      0   0     0.0     0.305    24    0

从上面的输出中，我们可以看到第一列给出了行号，这对于引用特定观察结果非常有用。

Checking Dimensions of Data

了解我们为机器学习项目准备的行列数据量始终是一个好习惯。背后的原因是 −

假设如果我们有太多行和列，那么运行算法和训练模型将需要很长时间。
假设如果我们有太少的行和列，那么我们就没有足够的数据来很好地训练模型。

以下是通过在 Pandas 数据框架中打印 shape 属性来实现的 Python 脚本。我们将对 iris 数据集进行实现以获取其中的行数和列数。

Example

from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.shape)

Output

(150, 4)

我们可以从输出中轻松观察到，我们将要使用的 iris 数据集共有 150 行和 4 列。

Getting Each Attribute’s Data Typ

了解每个属性的数据类型是另一个好习惯。背后的原因是，根据要求，有时我们可能需要将一种数据类型转换为另一种数据类型。例如，我们可能需要将字符串转换为浮点数或整数来表示分类或序数。我们可以通过查看原始数据来了解属性的数据类型，但另一种方法是使用 Pandas DataFrame 的 dtypes 属性。在 dtypes 属性的帮助下，我们可以对每个属性的数据类型进行分类。借助以下 Python 脚本可以理解 −

Example

from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.dtypes)

Output

sepal_length float64
sepal_width float64
petal_length float64
petal_width float64
dtype: object

从上面的输出中，我们可以轻松获得每个属性的数据类型。

Statistical Summary of Data

我们讨论了 Python 配方以获取数据的形状，即行数和列数，但很多时候我们需要查看该数据形状的摘要。这可以通过 Pandas DataFrame 的 describe() 函数来完成，该函数进一步提供每个数据属性的以下 8 个统计属性 −

Count
Mean
Standard Deviation
Minimum Value
Maximum value
25%
Median i.e. 50%
75%

Example

from pandas import read_csv
from pandas import set_option
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
set_option('display.width', 100)
set_option('precision', 2)
print(data.shape)
print(data.describe())

Output

(768, 9)
         preg      plas       pres      skin      test        mass       pedi      age      class
count 768.00      768.00    768.00     768.00    768.00     768.00     768.00    768.00    768.00
mean    3.85      120.89     69.11      20.54     79.80      31.99       0.47     33.24      0.35
std     3.37       31.97     19.36      15.95    115.24       7.88       0.33     11.76      0.48
min     0.00        0.00      0.00       0.00      0.00       0.00       0.08     21.00      0.00
25%     1.00       99.00     62.00       0.00      0.00      27.30       0.24     24.00      0.00
50%     3.00      117.00     72.00      23.00     30.50      32.00       0.37     29.00      0.00
75%     6.00      140.25     80.00      32.00    127.25      36.60       0.63     41.00      1.00
max    17.00      199.00    122.00      99.00    846.00      67.10       2.42     81.00      1.00

从上面的输出中，我们可以观察到 Pima Indian Diabetes 数据集的数据统计摘要以及数据形状。

Reviewing Class Distribution

类分布统计在分类问题中很有用，在这些问题中我们需要了解类值之间的平衡。了解类值分布非常重要，因为如果我们的类分布极不平衡，即一个类的观察值远多于另一个类，那么在机器学习项目的 data preparation 阶段可能需要特殊处理。我们可以借助 Pandas DataFrame 轻松地在 Python 中获取类分布。

Example

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
count_class = data.groupby('class').size()
print(count_class)

Output

Class
0 500
1 268
dtype: int64

从上面的输出中可以清楚地看出，类 0 的观测值数量几乎是类 1 的观测值数量的两倍。

Reviewing Correlation between Attributes

两个变量之间的关系称为相关性。在统计学中，计算相关性的最常用方法是皮尔逊相关系数。它可以具有以下三个值 −

Coefficient value = 1 − 它表示变量之间完全 positive 相关。
Coefficient value = -1 − 它表示变量之间完全 negative 相关。
Coefficient value = 0 − 它表示变量之间完全 no 相关。

在我们将其用于 ML 项目之前，始终审阅我们数据集中的属性对相关性非常有益，因为如果我们具有高度相关的属性，某些机器学习算法（如线性回归和逻辑回归）的性能会很差。在 Python 中，我们可以借助 Pandas DataFrame 上的 corr() 函数轻松计算数据集属性的相关性矩阵。

Example

from pandas import read_csv
from pandas import set_option
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
set_option('display.width', 100)
set_option('precision', 2)
correlations = data.corr(method='pearson')
print(correlations)

Output

preg     plas     pres     skin     test      mass     pedi       age      class
preg     1.00     0.13     0.14     -0.08     -0.07   0.02     -0.03       0.54   0.22
plas     0.13     1.00     0.15     0.06       0.33   0.22      0.14       0.26   0.47
pres     0.14     0.15     1.00     0.21       0.09   0.28      0.04       0.24   0.07
skin    -0.08     0.06     0.21     1.00       0.44   0.39      0.18      -0.11   0.07
test    -0.07     0.33     0.09     0.44       1.00   0.20      0.19      -0.04   0.13
mass     0.02     0.22     0.28     0.39       0.20   1.00      0.14       0.04   0.29
pedi    -0.03     0.14     0.04     0.18       0.19   0.14      1.00       0.03   0.17
age      0.54     0.26     0.24     -0.11     -0.04   0.04      0.03       1.00   0.24
class    0.22     0.47     0.07     0.07       0.13   0.29      0.17       0.24   1.00

上方输出中的矩阵提供了数据集中的所有成对属性之间的相关性。

Reviewing Skew of Attribute Distribution

偏度可以定义为一个假定为高斯分布但看起来已向另一个方向扭曲或偏移，或朝左或朝右的分布。审阅属性的偏度至关重要，原因如下所述−

数据中出现偏度需要在数据准备阶段进行校正，以便我们从模型中获得更高精度。
大多数 ML 算法假设数据呈高斯分布，即产生正态或钟形曲线数据。

在 Python 中，我们可以通过对 Pandas DataFrame 使用 skew() 函数轻松计算每个属性的偏差。

Example

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
print(data.skew())

Output

preg   0.90
plas   0.17
pres  -1.84
skin   0.11
test   2.27
mass  -0.43
pedi   1.92
age    1.13
class  0.64
dtype: float64

从以上输出中，可以观察到正偏差或负偏差。如果数值接近于 0，则表示偏差较小。

ML - Understanding Data with Visualization

Introduction

在上一章中，我们讨论了机器学习算法对数据的重要性以及使用 Python 配方了解数据统计信息。还有一种称为可视化的方法来理解数据。

借助数据可视化，我们可以看到数据的表现形式以及数据的属性持有哪种相关性。这是查看特征是否对应输出的最快方法。借助以下 Python 配方，我们可以用统计数据理解 ML 数据。

Univariate Plots: Understanding Attributes Independently

最简单的可视化类型是单变量或“单变量”可视化。借助单变量可视化，我们可以独立了解数据集的每个属性。以下是 Python 中实现单变量可视化的某些技术 -

Histograms

直方图将数据分组到区间中，并且是获取数据集中的每个属性的分布想法的最快方法。以下是直方图的一些特性 -

它为我们提供了为可视化创建的每个区间中的观察总数。
从区间的形状，我们可以轻松观察到分布，即它是高斯分布、偏态分布还是指数分布。
直方图还帮助我们看到可能的异常值。

Example

以下显示的代码是创建 Pima Indian Diabetes 数据集的属性直方图的 Python 脚本示例。在这里，我们将使用 Pandas DataFrame 上的 hist() 函数生成直方图和 matplotlib 用于绘制它们。

from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.hist()
pyplot.show()

Output

上面的输出显示它为数据集中每个属性创建了直方图。从中，我们可以观察到也许 age、pedi 和 test 属性可能是指数分布，而 mass 和 plas 是高斯分布。

Density Plots

获得每个属性分布的另一种快速简单的技术是密度图。它也类似于直方图，但在每个区间的顶部绘制一条平滑曲线。我们可以将它们称为抽象直方图。

Example

在以下示例中，Python 脚本将生成 Pima Indian Diabetes 数据集的属性分布的密度图。

from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.plot(kind='density', subplots=True, layout=(3,3), sharex=False)
pyplot.show()

Output

从上面的输出中，可以很容易地理解密度图和直方图之间的差异。

Box and Whisker Plots

箱线图，简称箱形图，是审查每个属性分布的另一种有用技术。以下はこのテクニックの特徴です -

它本质上是单变量的，总结每个属性的分布。
它为中间值（即中位数）划一条线。
它在 25% 和 75% 周围绘制一个盒子。
它还绘制了条形图，这些条形图将让我们了解数据的分布。
条形图之外的点表示异常值。异常值将比中间数据的分布大小大 1.5 倍。

Example

在以下示例中，Python 脚本将生成 Pima Indian Diabetes 数据集的属性分布的密度图。

from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.plot(kind='box', subplots=True, layout=(3,3), sharex=False,sharey=False)
pyplot.show()

Output

从上面绘制的属性分布图可以观察到，年龄、测试和皮肤对较小的值呈偏态。

Multivariate Plots: Interaction Among Multiple Variables

另一种可视化类型是多变量或“多变量”可视化。借助多变量可视化，我们可以了解数据集中多个属性之间的交互。以下是 Python 中用于实现多变量可视化的某些技术 -

Correlation Matrix Plot

相关性是关于两个变量之间变化的指示。在之前的章节中，我们讨论了皮尔森相关系数和相关性的重要性。我们可以绘制相关矩阵以显示哪些变量相对于另一个变量具有高或低相关性。

Example

在以下示例中，Python 脚本将为皮马印第安人糖尿病数据集生成并绘制相关矩阵。它可以在 Pandas DataFrame 上使用 corr() 函数生成，并在 pyplot 的帮助下绘制。

from matplotlib import pyplot
from pandas import read_csv
import numpy
Path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(Path, names=names)
correlations = data.corr()
fig = pyplot.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(correlations, vmin=-1, vmax=1)
fig.colorbar(cax)
ticks = numpy.arange(0,9,1)
ax.set_xticks(ticks)
ax.set_yticks(ticks)
ax.set_xticklabels(names)
ax.set_yticklabels(names)
pyplot.show()

Output

从相关矩阵的上述输出中，我们可以看到它是对称的，即左下角与右上角相同。还观察到每个变量都彼此正相关。

Scatter Matrix Plot

散点图展示了在二维平面上，一个变量受另一个变量影响的程度或它们之间的关系。散点图非常像折线图，因为它们使用水平和垂直轴绘制数据点。

Example

在以下示例中，Python 脚本将为皮马印第安人糖尿病数据集生成并绘制散点矩阵。它可以在 Pandas DataFrame 上使用 scatter_matrix() 函数生成，并在 pyplot 的帮助下绘制。

from matplotlib import pyplot
from pandas import read_csv
from pandas.tools.plotting import scatter_matrix
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
scatter_matrix(data)
pyplot.show()

Output

Machine Learning with Python - Preparing Data

Introduction

机器学习算法完全依赖于数据，因为数据是使模型训练成为可能的至关重要的方面。另一方面，如果我们在将数据输入 ML 算法之前无法理解数据，机器将毫无用处。简而言之，对于我们希望机器解决的问题，我们总是需要输入正确的数据，即按正确比例、格式且包含有意义特征的数据。

这使得数据准备成为 ML 处理中最重要的步骤。数据准备可以定义为使我们的数据集更适用于 ML 处理的过程。

Why Data Pre-processing?

在选择 ML 训练的原始数据后，最重要的任务是数据预处理。广义上讲，数据预处理将选定的数据转换为我们可以处理或可以输入 ML 算法的形式。我们总是需要预处理我们的数据，以便它可以符合机器学习算法的期望。

Data Pre-processing Techniques

以下数据预处理技术可以应用于数据集以生成 ML 算法的数据 −

Scaling

我们数据集很可能包含具有不同比例的属性，但是我们不能将此类数据提供给 ML 算法，因此需要重新缩放。数据重新缩放确保属性具有相同的比例。一般来说，将属性重新缩放为 0 到 1 的范围。梯度下降和 k 近邻等 ML 算法需要缩放数据。我们可以借助 scikit-learn Python 库的 MinMaxScaler 类重新缩放数据。

Example

在这个示例中，我们将重新缩放我们之前使用的 Pima Indians Diabetes 数据集的数据。首先，将加载 CSV 数据（如前几章中所做的那样），然后借助 MinMaxScaler 类，将数据重新缩放至 0 和 1 之间的范围。

以下脚本的前几行与我们在加载 CSV 数据时在之前的章节中写的一样。

from pandas import read_csv
from numpy import set_printoptions
from sklearn import preprocessing
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

现在，我们可以使用 MinMaxScaler 类将数据重新缩放到 0 和 1 的范围内。

data_scaler = preprocessing.MinMaxScaler(feature_range=(0,1))
data_rescaled = data_scaler.fit_transform(array)

我们还可以根据自己的选择总结数据以供输出。在这里，我们将精度设置为 1，并在输出中显示前 10 行。

set_printoptions(precision=1)
print ("\nScaled data:\n", data_rescaled[0:10])

Output

Scaled data:
[[0.4 0.7 0.6 0.4 0. 0.5 0.2 0.5 1. ]
[0.1 0.4 0.5 0.3 0. 0.4 0.1 0.2 0. ]
[0.5 0.9 0.5 0. 0. 0.3 0.3 0.2 1. ]
[0.1 0.4 0.5 0.2 0.1 0.4 0. 0. 0. ]
[0. 0.7 0.3 0.4 0.2 0.6 0.9 0.2 1. ]
[0.3 0.6 0.6 0. 0. 0.4 0.1 0.2 0. ]
[0.2 0.4 0.4 0.3 0.1 0.5 0.1 0.1 1. ]
[0.6 0.6 0. 0. 0. 0.5 0. 0.1 0. ]
[0.1 1. 0.6 0.5 0.6 0.5 0. 0.5 1. ]
[0.5 0.6 0.8 0. 0. 0. 0.1 0.6 1. ]]

从上述输出中，所有数据都重新缩放到 0 和 1 的范围内。

Normalization

另一种有用的数据预处理技术是归一化。这用于将每行数据重新缩放为长度为 1。它主要用于我们有很多零的稀疏数据集。我们可以借助 scikit-learn Python 库的 Normalizer 类重新缩放数据。

Types of Normalization

在机器学习中，有两种归一化预处理技术，如下所示 −

L1 Normalization

它可以定义为一种归一化技术，它以一种方式修改数据集值，使得每一行的绝对值之和始终高达 1。它也称为最小绝对偏差。

Example

在此示例中，我们使用 L1 归一化技术来归一化我们先前使用的 Pima Indians 糖尿病数据集的数据。首先，将加载 CSV 数据，然后在 Normalizer 类的帮助下对其进行归一化。

以下脚本的前几行与我们在加载 CSV 数据时在之前的章节中写的一样。

from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values

现在，我们可以使用 L1 的 Normalizer 类来对数据进行归一化。

Data_normalizer = Normalizer(norm='l1').fit(array)
Data_normalized = Data_normalizer.transform(array)

我们还可以根据自己的选择总结数据以供输出。在这里，我们将精度设置为 2，并在输出中显示前 3 行。

set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])

Output

Normalized data:
[[0.02 0.43 0.21 0.1 0. 0.1 0. 0.14 0. ]
[0. 0.36 0.28 0.12 0. 0.11 0. 0.13 0. ]
[0.03 0.59 0.21 0. 0. 0.07 0. 0.1 0. ]]

L2 Normalization

它可以定义为一种归一化技术，它以一种方式修改数据集值，使得每一行的平方和始终高达 1。它也称为最小二乘。

Example

在此示例中，我们使用 L2 归一化技术来归一化我们先前使用的 Pima Indians 糖尿病数据集的数据。首先，将加载 CSV 数据（如前几章中所述），然后在 Normalizer 类的帮助下对其进行归一化。

以下脚本的前几行与我们在加载 CSV 数据时在之前的章节中写的一样。

from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values

现在，我们可以使用 L1 的 Normalizer 类来对数据进行归一化。

Data_normalizer = Normalizer(norm='l2').fit(array)
Data_normalized = Data_normalizer.transform(array)

我们还可以根据自己的选择总结数据以供输出。在这里，我们将精度设置为 2，并在输出中显示前 3 行。

set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])

Output

Normalized data:
[[0.03 0.83 0.4 0.2 0. 0.19 0. 0.28 0.01]
[0.01 0.72 0.56 0.24 0. 0.22 0. 0.26 0. ]
[0.04 0.92 0.32 0. 0. 0.12 0. 0.16 0.01]]

Binarization

顾名思义，这是一个可以帮助我们使数据实现二进制化的技术。我们可以使用二进制阈值使数据实现二进制化。高于该阈值的值将转换为 1，低于该阈值的值将转换为 0。例如，如果我们选择阈值 = 0.5，则数据集值高于该值将变为 1，低于则变为 0。这就是为什么我们可以称之为 binarizing 数据或 thresholding 数据。当我们数据集中有概率并希望将它们转换为固定值时，这个技术很有用。

我们可以借助 scikit-learn Python 库中的 Binarizer 类对数据进行二值化。

Example

在这个示例中，我们将重新调整前面使用过的 Pima Indians Diabetes 数据集的数据。首先，将加载 CSV 数据，然后借助 Binarizer 类，根据阈值将其转换为二进制值，即 0 和 1。我们选择 0.5 作为阈值。

以下脚本的前几行与我们在加载 CSV 数据时在之前的章节中写的一样。

from pandas import read_csv
from sklearn.preprocessing import Binarizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

现在，我们可以使用 Binarize 类将该数据转换为二进制值。

binarizer = Binarizer(threshold=0.5).fit(array)
Data_binarized = binarizer.transform(array)

在此处，我们显示输出中的前 5 行。

print ("\nBinary data:\n", Data_binarized [0:5])

Output

Binary data:
[[1. 1. 1. 1. 0. 1. 1. 1. 1.]
[1. 1. 1. 1. 0. 1. 0. 1. 0.]
[1. 1. 1. 0. 0. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 0. 1. 0.]
[0. 1. 1. 1. 1. 1. 1. 1. 1.]]

Standardization

另一种有用的数据预处理技术，它基本上用于转换具有高斯分布的数据属性。它将均值和 SD（标准差）与均值为 0 和 SD 为 1 的标准高斯分布区分开来。这种技术在 ML 算法中很有用，例如线性回归和逻辑回归，它假设输入数据集中的高斯分布并且使用重新缩放的数据生成更好的结果。我们可以借助 scikit-learn Python 库的 StandardScaler 类标准化数据（均值 = 0 和 SD =1）。

Example

在此示例中，我们将重新调整先前使用的 Pima Indians 糖尿病数据集的数据。首先，将加载 CSV 数据，然后在 StandardScaler 类的帮助下，将其转换为均值 = 0 和 SD = 1 的高斯分布。

以下脚本的前几行与我们在加载 CSV 数据时在之前的章节中写的一样。

from sklearn.preprocessing import StandardScaler
from pandas import read_csv
from numpy import set_printoptions
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

现在，我们可以使用 StandardScaler 类来重新缩放到数据。

data_scaler = StandardScaler().fit(array)
data_rescaled = data_scaler.transform(array)

我们还可以根据自己的选择总结数据以供输出。在这里，我们将精度设置为 2，并在输出中显示前 5 行。

set_printoptions(precision=2)
print ("\nRescaled data:\n", data_rescaled [0:5])

Output

Rescaled data:
[[ 0.64 0.85 0.15 0.91 -0.69 0.2 0.47 1.43 1.37]
[-0.84 -1.12 -0.16 0.53 -0.69 -0.68 -0.37 -0.19 -0.73]
[ 1.23 1.94 -0.26 -1.29 -0.69 -1.1 0.6 -0.11 1.37]
[-0.84 -1. -0.16 0.15 0.12 -0.49 -0.92 -1.04 -0.73]
[-1.14 0.5 -1.5 0.91 0.77 1.41 5.48 -0.02 1.37]]

Data Labeling

我们讨论了优质数据对于 ML 算法的重要性以及在将数据发送到 ML 算法之前预处理数据的一些技术。在这方面另一个方面是数据标记。将具有适当标记的数据发送到 ML 算法也非常重要。例如，对于分类问题，数据上存在许多以单词、数字等形式出现的标签。

What is Label Encoding?

大多数 sklearn 函数都需要的是以数字标记表示的数据，而不是以单词标记的数据。因此，我们需要将此类标记转换为数字标记。此过程称为标记编码。我们可以借助 scikit-learn Python 库的 LabelEncoder() 函数对数据执行标记编码。

Example

在以下示例中，Python 脚本将执行标记编码。

首先，按如下方式导入所需的 Python 库 −

import numpy as np
from sklearn import preprocessing

现在，我们需要提供输入标记，如下所示 −

input_labels = ['red','black','red','green','black','yellow','white']

代码的下一行将创建标记编码器并对其进行训练。

encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)

脚本的下一行将通过对随机有序的列表进行编码来检查性能 −

test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)
print("Encoded values =", list(encoded_values))
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)

我们可以借助以下 python 脚本获取编码值列表 −

print("\nEncoded values =", encoded_values)
print("\nDecoded labels =", list(decoded_list))

Output

Labels = ['green', 'red', 'black']
Encoded values = [1, 2, 0]
Encoded values = [3, 0, 4, 1]
Decoded labels = ['white', 'black', 'yellow', 'green']

ML with Python - Data Feature Selection

在上一章节中，我们详细了解了如何对用于机器学习的数据进行预处理和准备。在这一章节中，让我们详细了解数据特征选择及其所涉及的各个方面。

Importance of Data Feature Selection

机器学习模型的性能与用于对其训练的数据特征成正比。如果向其提供不相关的数据特征，将会对 ML 模型的性能产生负面影响。另一方面，使用相关数据特征可以提高 ML 模型的准确性，尤其是线性回归和逻辑回归。

现在的问题是，什么是自动特征选择？它可以定义为一个过程，借助这个过程，我们可以选择我们数据中最与我们感兴趣的输出或预测变量相关的特征。它也称为属性选择。

以下是在对数据建模之前进行自动特征选择的一些好处：

在数据建模之前执行特征选择将减少过拟合。
在数据建模之前执行特征选择将提高 ML 模型的准确性。
在数据建模之前执行特征选择将减少训练时间

Feature Selection Techniques

以下是我们可以在 Python 中用于对 ML 数据建模的自动特征选择技术：

Univariate Selection

此特征选择技术对于选择那些与预测变量具有最强关系（借助统计测试）的特征非常有用。我们可以借助 scikit-learn Python 库的 SelectKBest0 类来实现单变量特征选择技术。

Example

在这个示例中，我们将使用皮马印第安人糖尿病数据集来选择 4 个具有最佳特征的属性（借助卡方统计测试）。

from pandas import read_csv
from numpy import set_printoptions
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

接下来，我们将数组分成输入和输出组件：

X = array[:,0:8]
Y = array[:,8]

以下代码行将从数据集中选择最佳特征：

test = SelectKBest(score_func=chi2, k=4)
fit = test.fit(X,Y)

我们还可以根据自己的选择来总结输出数据。在这里，我们设置精度为 2，并显示具有最佳特征的 4 个数据属性以及每个属性的最佳分数：

set_printoptions(precision=2)
print(fit.scores_)
featured_data = fit.transform(X)
print ("\nFeatured data:\n", featured_data[0:4])

Output

[ 111.52 1411.89 17.61 53.11 2175.57 127.67 5.39 181.3 ]
Featured data:
[[148. 0. 33.6 50. ]
[ 85. 0. 26.6 31. ]
[183. 0. 23.3 32. ]
[ 89. 94. 28.1 21. ]]

Recursive Feature Elimination

顾名思义，RFE（递归特征消除）特征选择技术会递归地删除属性，并使用剩余属性构建模型。我们可以借助 scikit-learn Python 库的 RFE 类来实现 RFE 特征选择技术。

Example

在这个示例中，我们将使用 RFE 连同逻辑回归算法从皮马印第安人糖尿病数据集中选择具有最佳特征的最佳 3 个属性。

from pandas import read_csv
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

接下来，我们将数组分成其输入和输出组件：

X = array[:,0:8]
Y = array[:,8]

以下代码行将从数据集中选择最佳特征：

model = LogisticRegression()
rfe = RFE(model, 3)
fit = rfe.fit(X, Y)
print("Number of Features: %d")
print("Selected Features: %s")
print("Feature Ranking: %s")

Output

Number of Features: 3
Selected Features: [ True False False False False True True False]
Feature Ranking: [1 2 3 5 6 1 1 4]

我们可以在以上输出中看到，RFE 选择了 preg、mass 和 pedi 作为前 3 个最佳特征。它们在输出中标记为 1。

Principal Component Analysis (PCA)

PCA 通常称为数据还原技术，它是一种非常有用的特征选择技术，因为它使用线性代数将数据集转换为压缩形式。我们可以借助 scikit-learn Python 库的 PCA 类来实现 PCA 特征选择技术。我们可以在输出中选择主成分的数量。

Example

在此示例中，我们将使用 PCA 从 Pima Indians Diabetes 数据集中选择最佳的 3 个主成分。

from pandas import read_csv
from sklearn.decomposition import PCA
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

接下来，我们将数组分成输入和输出组件：

X = array[:,0:8]
Y = array[:,8]

以下几行代码将从数据集中提取特征 -

pca = PCA(n_components=3)
fit = pca.fit(X)
print("Explained Variance: %s") % fit.explained_variance_ratio_
print(fit.components_)

Output

Explained Variance: [ 0.88854663 0.06159078 0.02579012]
[[ -2.02176587e-03 9.78115765e-02 1.60930503e-02 6.07566861e-02
9.93110844e-01 1.40108085e-02 5.37167919e-04 -3.56474430e-03]
[ 2.26488861e-02 9.72210040e-01 1.41909330e-01 -5.78614699e-02
-9.46266913e-02 4.69729766e-02 8.16804621e-04 1.40168181e-01]
[ -2.24649003e-02 1.43428710e-01 -9.22467192e-01 -3.07013055e-01
2.09773019e-02 -1.32444542e-01 -6.39983017e-04 -1.25454310e-01]]

我们可以从以上输出看到，3 个主成分与源数据几乎没有相似之处。

Feature Importance

顾名思义，特征重要性技术用来挑选重要特征。它基本上使用受过训练的有监督分类器来选择特征。我们可以通过 scikit-learn Python 库的 ExtraTreeClassifier 类来实现此特征选择技术。

Example

在此示例中，我们将使用 ExtraTreeClassifier 从 Pima Indians Diabetes 数据集中选择特征。

from pandas import read_csv
from sklearn.ensemble import ExtraTreesClassifier
path = r'C:\Desktop\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(data, names=names)
array = dataframe.values

接下来，我们将数组分成输入和输出组件：

X = array[:,0:8]
Y = array[:,8]

以下几行代码将从数据集中提取特征 -

model = ExtraTreesClassifier()
model.fit(X, Y)
print(model.feature_importances_)

Output

[ 0.11070069 0.2213717 0.08824115 0.08068703 0.07281761 0.14548537 0.12654214 0.15415431]

从输出中，我们可以看到每个属性都有得分。得分越高，该属性就越重要。

Classification - Introduction

Introduction to Classification

分类可以定义为从观察到的值或给定的数据点中预测类或类别。分类后的输出形式可以是“黑”或“白”或“垃圾邮件”或“无垃圾邮件”。

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

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

为了实现此分类，我们首先需要训练分类器。对于此示例，“垃圾邮件”和“无垃圾邮件”电子邮件将用作训练数据。成功训练分类器后，可将其用于检测未知电子邮件。

Types of Learners in Classification

在分类问题中，我们有两种类型的学习器——

Lazy Learners

顾名思义，此类学习器会等待在存储训练数据后出现的测试数据。只有在获取测试数据后才会执行分类。它们花费在训练上的时间较少，而花费在预测上的时间较多。惰性学习器的示例包括 k 近邻和基于案例的推理。

Eager Learners

与惰性学习器相反，主动学习器会在存储训练数据后等待在测试数据出现后构建分类模型。它们花费在训练上的时间较多，而花费在预测上的时间较少。主动学习器的示例包括决策树、朴素贝叶斯和人工神经网络 (ANN)。

Building a Classifier in Python

Scikit-learn（一个用于机器学习的 Python 库）可用于在 Python 中构建分类器。在 Python 中构建分类器的步骤如下——

Step1: Importing necessary python package

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

import sklearn

Step2: Importing dataset

导入必要的包后，我们需要一个数据集来构建分类预测模型。我们可以从 sklearn 数据集导入它，也可以根据我们的要求使用其他数据集。我们将使用 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']

以下命令将打印标签的名称，“malignant”和“benign”，针对我们的数据库的情况。

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]

Step3: Organizing data into training & testing sets

因为我们需要在不可见数据上测试我们的模型，我们会将我们的数据集分成两部分：一个训练集和一个测试集。我们可以使用 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)

Step4 - Model evaluation

在将数据分成训练和测试后，我们需要构建模型。为此，我们将使用朴素贝叶斯算法。以下命令会导入 GaussianNB 模块 −

from sklearn.naive_bayes import GaussianNB

现在，初始化模型如下所示 −

gnb = GaussianNB()

接下来，在以下命令的帮助下，我们可以训练模型 −

model = gnb.fit(train, train_labels)

现在，为了评估的目的，我们需要进行预测。它可以通过使用 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 是 Malignant 和 Benign 肿瘤分类的预测值。

Step5- Finding accuracy

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

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

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

Classification Evaluation Metrics

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

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

Confusion Matrix

这是衡量分类问题性能的最简单方法，其中输出可以是两种或更多种类的类。混淆矩阵只不过是一个有两维的表格，即“实际”和“预测”，此外，这两个维度都具有“真阳性（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

Output

[[ 73 7]
[ 4 144]]

Accuracy

可以将其定义为由我们的机器学习模型做出的正确预测的数目。我们可以通过以下公式借助混淆矩阵轻松计算它 -

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

因此，准确性 = 217/228 = 0.951754385965，这与我们在创建二元分类器后计算得出的值相同。

Precision

精度，用于文档检索，可以定义为由我们的机器学习模型返回的正确文档数。我们可以通过以下公式借助混淆矩阵轻松计算它 -

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

因此，精度 = 73/80 = 0.915

Recall or Sensitivity

召回率可以定义为由我们的机器学习模型返回的正例数。我们可以通过以下公式借助混淆矩阵轻松计算它 -

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

因此，精度 = 73/77 = 0.94805

Specificity

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

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

因此，精度 = 144/151 = 0.95364

Various ML Classification Algorithms

以下是某些重要的 ML 分类算法 −

Logistic Regression
Support Vector Machine (SVM)
Decision Tree
Naïve Bayes
Random Forest

我们将在后面的章节中详细讨论所有这些分类算法。

Applications

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

Speech Recognition
Handwriting Recognition
Biometric Identification
Document Classification

Classification Algorithms - Logistic Regression

Introduction to Logistic Regression

逻辑回归是一种有监督学习分类算法，用于预测目标变量的概率。目标或因变量的本质是二分的，这意味着仅有两个可能的类别。

简言之，因变量本质上是二元的，数据被编码为 1（表示成功/是）或 0（表示失败/否）。

在数学上，逻辑回归模型会预测 P(Y=1) 作为 X 的函数。它是可以用于各种分类问题的最简单的 ML 算法之一，例如垃圾邮件检测、糖尿病预测、癌症检测等。

Types of Logistic Regression

通常，逻辑回归意味着具有二进制目标变量的二进制逻辑回归，但可能有更多两类目标变量可以通过它来预测。基于这些类别的数量，逻辑回归可以划分为以下类型 -

Binary or Binomial

在这种分类中，因变量只有两种可能的类型 1 和 0。例如，这些变量可能表示成功或失败、是或否、赢或输等。

Multinomial

在这种分类中，因变量可能有 3 个或更多种可能的无序类型或没有定量意义的类型。例如，这些变量可能表示“类型 A”或“类型 B”或“类型 C”。

Ordinal

在这种分类中，因变量可能有 3 个或更多种可能的有序类型或具有定量意义的类型。例如，这些变量可能表示“差”或“好”、“非常好”、“优秀”，每个类别都可以有 0、1、2、3 等得分。

Logistic Regression Assumptions

在开始实现逻辑回归之前，我们必须认识到以下关于此算法的假设 -

在二进制逻辑回归的情况下，目标变量必须始终是二进制的，并且期望的结果由因子水平 1 表示。
模型中不应有任何多重共线性，这意味着自变量必须相互独立。
我们必须在模型中包含有意义的变量。
我们应该为逻辑回归选择较大的样本量。

Binary Logistic Regression model

逻辑回归最简单的形式是二元或二项逻辑回归，其中目标变量或因变量可以仅具有两种可能的类型，即 1 或 0。它允许我们对多个预测变量和二元/二项目标变量建模关系。对于逻辑回归，线性函数基本作为另一个函数（例如下面的关系中的𝑔）的输入使用 -

这里，𝑔是逻辑斯蒂或 sigmoid 函数，可以表示如下 -

sigmoid 曲线可以借助下面的图像表示。我们可以看到 y 轴的值介于 0 到 1 之间，并且在 0.5 处穿过轴。

类别可以分为正类或负类。输出落在 0 到 1 之间时，即正类的概率。对于我们的实现，我们解释假设函数的输出，如果它≥0.5 为正，否则为负。

我们还需要定义一个损失函数来度量算法使用函数权重的执行情况，该函数由 theta 如下所示 -

ℎ=𝑔(𝑋𝜃)

现在，在定义了损失函数后，我们的主要目标是最小化损失函数。可以通过帮助拟合权重来实现，这意味着增加或减少权重。借助于相对于每个权重的损失函数的导数，我们将能够了解哪些参数应该具有高权重以及哪些参数应该具有较小的权重。

以下梯度下降方程告诉我们如果我们修改参数，损失将如何改变 -

Implementation in Python

现在，我们将用 Python 实现二项式逻辑回归的上述概念。为此，我们使用了一个名为“iris”的多变量花数据集，其中有 3 类，每类有 50 个实例，但我们将使用前两个特征列。每个类代表一种鸢尾花。

首先，我们需要导入必需的库，如下所示 -

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets

然后，加载 iris 数据集，如下所示 -

iris = datasets.load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1

我们可以绘制我们的训练数据，如下所示 -

plt.figure(figsize=(6, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend();

接下来，我们将定义 sigmoid 函数、损失函数和梯度下降，如下所示 -

class LogisticRegression:
   def __init__(self, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):
      self.lr = lr
      self.num_iter = num_iter
      self.fit_intercept = fit_intercept
      self.verbose = verbose
   def __add_intercept(self, X):
      intercept = np.ones((X.shape[0], 1))
      return np.concatenate((intercept, X), axis=1)
   def __sigmoid(self, z):
      return 1 / (1 + np.exp(-z))
   def __loss(self, h, y):
      return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
   def fit(self, X, y):
      if self.fit_intercept:
         X = self.__add_intercept(X)

现在，初始化权重，如下所示 -

self.theta = np.zeros(X.shape[1])
   for i in range(self.num_iter):
      z = np.dot(X, self.theta)
      h = self.__sigmoid(z)
      gradient = np.dot(X.T, (h - y)) / y.size
      self.theta -= self.lr * gradient
      z = np.dot(X, self.theta)
      h = self.__sigmoid(z)
      loss = self.__loss(h, y)
      if(self.verbose ==True and i % 10000 == 0):
         print(f'loss: {loss} \t')

借助以下脚本，我们可以预测输出概率 -

def predict_prob(self, X):
   if self.fit_intercept:
      X = self.__add_intercept(X)
   return self.__sigmoid(np.dot(X, self.theta))
def predict(self, X):
   return self.predict_prob(X).round()

接下来，我们可以对模型进行评估并将其绘制如下 -

model = LogisticRegression(lr=0.1, num_iter=300000)
preds = model.predict(X)
(preds == y).mean()

plt.figure(figsize=(10, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend()
x1_min, x1_max = X[:,0].min(), X[:,0].max(),
x2_min, x2_max = X[:,1].min(), X[:,1].max(),
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
grid = np.c_[xx1.ravel(), xx2.ravel()]
probs = model.predict_prob(grid).reshape(xx1.shape)
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='red');

Multinomial Logistic Regression Model

另一种有用的逻辑回归形式是多项逻辑回归，其中目标变量或因变量可以具有 3 种或更多种可能的无序类型，即类型没有数量上的意义。

Implementation in Python

现在，我们将在 Python 中实现多项逻辑回归的上述概念。为此，我们正在使用一个名为 digit 的 sklearn 中的数据集。

首先，我们需要导入必需的库，如下所示 -

Import sklearn
from sklearn import datasets
from sklearn import linear_model
from sklearn import metrics
from sklearn.model_selection import train_test_split

接下来，我们需要加载 digit 数据集 -

digits = datasets.load_digits()

现在，定义特征矩阵 (X) 和响应矢量 (y) 如下所示 −

X = digits.data
y = digits.target

在下一行代码的帮助下，我们可以将 X 和 y 拆分为训练集和测试集 −

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)

现在按以下方式创建一个逻辑回归对象 −

digreg = linear_model.LogisticRegression()

现在，我们需要使用训练集训练模型，如下所示 −

digreg.fit(X_train, y_train)

接下来，按以下方式对测试集进行预测 −

y_pred = digreg.predict(X_test)

接下来按以下方式打印模型的准确度 −

print("Accuracy of Logistic Regression model is:",
metrics.accuracy_score(y_test, y_pred)*100)

Output

Accuracy of Logistic Regression model is: 95.6884561891516

从以上输出我们可以看到模型的准确度为 96%。

Support Vector Machine (SVM)

Introduction to SVM

支持向量机 (SVM) 功能强大且灵活，是监督机器学习算法，可同时用于分类和回归。但一般而言，它们用于分类问题。SVm 于 1960 年代首次推出，但后来在 1990 年得到了改进。与其他机器学习算法相比，SVM 具有独特的实现方式。近年来，由于其处理多个连续变量和分类变量的能力而备受青睐。

Working of SVM

SVM 模型本质上是对多维空间中超平面中不同类别的表示。SVM 会以迭代方式生成超平面，以便最大限度地减少错误。SVM 的目标是将数据集划分为不同的类别，以找到最大边缘超平面 (MMH)。

SVM 中的重要概念包括以下几个 −

Support Vectors - 最接近超平面的数据点称为支持向量。将利用这些数据点定义分隔线。
Hyperplane − 如以上图表所示，它是一个决策平面或空间，由一组具有不同类别的对象划分。
Margin - 它可以定义为不同类最近数据点上的两条线之间的间隙。它可以计算为从该线到支持向量的垂直距离。大间隔被认为是好间隔，小间隔被认为是坏间隔。

SVM 的主要目标是将数据集划分为不同类别，以找到最大边缘超平面 (MMH)，可以分两步完成 −

首先，SVM 将以迭代方式生成超平面，以最佳方式区分类别。
然后，它将选择正确划分类别的超平面。

Implementing SVM in Python

我们在 Python 中实现 SVM 的过程从导入标准库开始，如下所示 −

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import seaborn as sns; sns.set()

接下来，我们从 sklearn.dataset.sample_generator 使用 SVM 创建用于分类的线性可分离数据样本集 −

from sklearn.datasets.samples_generator import make_blobs
X, y = make_blobs(n_samples=100, centers=2,
      random_state=0, cluster_std=0.50)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');

在生成包含 100 个样本和 2 个簇的样本集后，输出如下 −

我们知道 SVM 支持判别分类。它通过在二维情况下简单地找到一条线或在多维情况下找到一个流形来区分不同的类。在上述数据集中实现 SVM 的过程如下 −

xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
plt.plot([0.6], [2.1], 'x', color='black', markeredgewidth=4, markersize=12)
for m, b in [(1, 0.65), (0.5, 1.6), (-0.2, 2.9)]:
   plt.plot(xfit, m * xfit + b, '-k')
plt.xlim(-1, 3.5);

输出如下 −

从上述输出中我们可以看到，有三个不同的分隔符完美地区分了上述样本。

如前所述，SVM 的主要目标是将数据集划分为类别以找到最大边缘超平面 (MMH)，因此，我们可以在类之间绘制零线，也可以围绕每条线绘制一个边缘，其宽度最多可达最近点。它可以如下完成——

xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
   for m, b, d in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]:
   yfit = m * xfit + b
   plt.plot(xfit, yfit, '-k')
   plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
         color='#AAAAAA', alpha=0.4)
plt.xlim(-1, 3.5);

从输出中的上述图像中，我们很容易观察到判别分类器中的“边缘”。SVM 将选择最大化边缘的线。

接下来，我们将使用 Scikit-Learn 的支持向量分类器对该数据训练 SVM 模型。在此，我们使用线性核来拟合 SVM，如下所示——

from sklearn.svm import SVC # "Support vector classifier"
model = SVC(kernel='linear', C=1E10)
model.fit(X, y)

输出如下 −

SVC(C=10000000000.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='auto_deprecated',
kernel='linear', max_iter=-1, probability=False, random_state=None,
shrinking=True, tol=0.001, verbose=False)

现在，为了更好地理解，以下内容将绘制二维 SVC 的决策函数——

def decision_function(model, ax=None, plot_support=True):
   if ax is None:
      ax = plt.gca()
   xlim = ax.get_xlim()
   ylim = ax.get_ylim()

为了评估模型，我们需要创建网格，如下所示——

x = np.linspace(xlim[0], xlim[1], 30)
y = np.linspace(ylim[0], ylim[1], 30)
Y, X = np.meshgrid(y, x)
xy = np.vstack([X.ravel(), Y.ravel()]).T
P = model.decision_function(xy).reshape(X.shape)

接下来，我们需要绘制决策边界和边缘，如下所示——

ax.contour(X, Y, P, colors='k',
   levels=[-1, 0, 1], alpha=0.5,
   linestyles=['--', '-', '--'])

现在，以类似的方式绘制支持向量，如下所示——

if plot_support:
   ax.scatter(model.support_vectors_[:, 0],
      model.support_vectors_[:, 1],
      s=300, linewidth=1, facecolors='none');
ax.set_xlim(xlim)
ax.set_ylim(ylim)

现在，使用此函数拟合我们的模型，如下所示——

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
decision_function(model);

我们可以从上述输出中观察到，一个 SVM 分类器适合具有裕度的数据，即虚线和支持向量，这是该拟合的关键元素，触及虚线。这些支持向量点存储在分类器的 support_vectors_ 属性中，如下所示——

model.support_vectors_

输出如下 −

array([[0.5323772 , 3.31338909],
   [2.11114739, 3.57660449],
   [1.46870582, 1.86947425]])

SVM Kernels

在实践中，SVM 算法使用将输入数据空间转换为所需形式的核来实现。SVM 使用称为核技巧的技术，其中核采用低维输入空间并将其转换为更高维的空间。简单来说，核通过向其中添加更多维度将不可分离的问题转换为可分离问题。它使 SVM 功能更强大、更灵活、更准确。以下是 SVM 使用的一些内核类型——

Linear Kernel

它可用作任意两个观测之间的点积。线性核的公式如下——

k(x,xi) = sum(x*xi)

从上述公式中，我们可以看到两个向量（例如 𝑥 和 𝑥𝑖）之间的乘积是输入值每对乘积的总和。

Polynomial Kernel

它是线性核的更通用形式，并且区分曲线或非线性输入空间。以下是多项式核的公式——

K(x, xi) = 1 + sum(x * xi)^d

其中 d 是多项式的度数，我们需要在学习算法中手动指定它。

Radial Basis Function (RBF) Kernel

RBF 核主要用于 SVM 分类，它将输入空间映射到无限维空间。以下公式在数学上对它进行了说明——

K(x,xi) = exp(-gamma * sumx – xi^2

在此，gamma 范围从 0 到 1。我们需要在学习算法中手动指定它。gamma 一个好的默认值为 0.1。

由于我们为线性可分离数据实现了 SVM，所以我们可以使用 Python 针对不可线性分离的数据实现它。可以通过使用核函数来实现这一点。

Example

下面是使用核函数创建 SVM 分类器的示例。我们将使用 scikit-learn 中的虹膜数据集：

我们将通过导入以下包来开始：

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

接下来，我们将使用原始数据按如下方式绘制 SVM 边界：

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.SVC(kernel='linear', C=C).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('Support Vector Classifier with linear kernel')

Output

Text(0.5, 1.0, 'Support Vector Classifier with linear kernel')

对于使用 rbf 核创建 SVM 分类器，我们可以按如下方式将核更改为 rbf ：

Svc_classifier = svm.SVC(kernel='rbf', gamma =‘auto’,C=C).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('Support Vector Classifier with rbf kernel')

Output

Text(0.5, 1.0, 'Support Vector Classifier with rbf kernel')

我们将 gamma 值设置为“自动”，但是你也可以提供 0 到 1 之间的值。

Pros and Cons of SVM Classifiers

Pros of SVM classifiers

SVM 分类器提供极高的准确度，并且在高维度空间中表现良好。SVM 分类器基本上使用训练点的子集，因此实际上使用非常少的内存。

Cons of SVM classifiers

它们的训练时间很长，因此在实践中不适用于大型数据集。另一个缺点是 SVM 分类器与重叠类别不匹配。

Classification Algorithms - Decision Tree

Introduction to Decision Tree

一般而言，决策树分析是一种预测建模工具，可应用于许多领域。决策树可以通过一种算法方法来构建，该方法可以基于不同条件以不同方式拆分数据集。决策树是最强大的算法，属于监督算法范畴。

它们可用于分类和回归任务。树的两个主要实体是决策节点（其中数据被拆分）和叶节点（其中我们得到结果）。下面给出了一个二叉树示例，用于预测人的健康状况，它提供了年龄、饮食习惯和锻炼习惯等各种信息：

在上述决策树中，问题是决策节点，最终结果是叶节点。我们有以下两种类型的决策树：

Classification decision trees - 在这种类型的决策树中，决策变量是分类变量。上述决策树是分类决策树的一个示例。
Regression decision trees - 在这种类型的决策树中，决策变量是连续变量。

Implementing Decision Tree Algorithm

Gini Index

这是用来评估数据集中二分类分割的成本函数名称，并且使用类别目标变量“成功”或“失败”。

基尼指数的值越高，同质性越高。完美的基尼指数值为 0，最差为 0.5（对于 2 类问题）。可以用以下步骤计算分割的基尼指数 −

首先，使用公式 p ^2+q 2 计算子节点的基尼指数，该公式是成功和失败概率的平方和。
接下来，使用每个节点的加权基尼得分计算分割的基尼指数。

分类和回归树 (CART) 算法使用基尼方法生成二进制分割。

Split Creation

分割基本上包括数据集中的一个属性和一个值。我们可以使用以下三部分在数据集中创建一个分割 −

Part1 − 计算基尼评分：我们刚刚在上文中讨论了这一部分。
Part2 − 分割数据集：它可以定义为将数据集划分为具有属性索引和属性分割值的两个行列表。从数据集中获得两个组——右组和左组后，我们可以使用第一部分中计算的基尼评分计算分割的值。分割值将决定属性所在的组。
Part3 − 评估所有分割：找到基尼评分并分割数据集之后，下一步是评估所有分割。为此，我们首先必须检查与每个属性关联的每个值作为候选分割。然后，我们需要通过评估分割的成本来找到可能的最佳分割。最佳分割将用作决策树中的一个节点。

Building a Tree

众所周知，一颗树有根节点和终节点。创建根节点后，我们可以按照以下两部分构建树 −

Part1: Terminal node creation

在创建决策树的终节点时，一个重要的一点是确定何时停止加深树或创建更多终节点。它可以用两个标准来完成，即最大树深度和最小节点记录，如下所示 −

Maximum Tree Depth − 名称表明，这是根节点之后树中的最大节点数。当树达到最大深度时，即当树获得最大数量的终节点时，我们必须停止添加终节点。
Minimum Node Records − 它可以定义为给定节点负责的最小数量的训练模式。当树达到这些最小节点记录或低于该最小值时，我们必须停止添加终节点。

终节点用于做出最终预测。

Part2: Recursive Splitting

当我们了解何时创建终节点时，我们现在可以开始构建树。递归分割是一种构建树的方法。用这种方法，一旦创建一个节点，我们就可以对由分割数据集生成的数据的每一组递归创建子节点（添加到现有节点的节点），方法是反复调用同一个函数。

Prediction

在构建决策树之后，我们需要对它进行预测。本质上，预测涉及使用特定提供的数据行浏览决策树。

我们可以使用递归函数进行预测，如上所述。使用左右子节点再次调用相同的预测程序。

Assumptions

我们在创建决策树时做出的假设如下 −

在准备决策树时，训练集为根节点。
决策树分类器更倾向于分类特征值。如果想使用连续值，则必须在构建模型之前对其进行离散化处理。
根据属性值，递归地分布记录。
统计方法将用于将属性置于任何节点位置，即根节点或内部节点。

Implementation in Python

Example

在以下示例中，我们将对 Pima 印第安人糖尿病实施决策树分类器——

首先，从导入必要的 Python 包开始——

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

接下来，从其 Web 链接下载 iris 数据集，如下所示——

col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
pima = pd.read_csv(r"C:\pima-indians-diabetes.csv", header=None, names=col_names)
pima.head()

      pregnant    glucose  bp    skin  insulin  bmi   pedigree    age   label
0       6         148      72    35     0       33.6    0.627     50      1
1       1         85       66    29     0       26.6    0.351     31      0
2       8         183      64     0     0       23.3    0.672     32      1
3       1         89       66    23     94      28.1    0.167     21      0
4       0         137      40    35     168     43.1    2.288     33      1

现在，将数据集拆分为特征和目标变量，如下所示——

feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
X = pima[feature_cols] # Features
y = pima.label # Target variable

接下来，我们将数据分为训练和测试拆分。以下代码将数据集拆分为 70% 的训练数据和 30% 的测试数据——

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

接下来，使用 sklearn 的 DecisionTreeClassifier 类对模型进行训练，如下所示——

clf = DecisionTreeClassifier()
clf = clf.fit(X_train,y_train)

最后，我们需要进行预测。可以使用以下脚本完成——

y_pred = clf.predict(X_test)

接下来，我们可以得到准确度得分、混淆矩阵和分类报告，如下所示——

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

Output

Confusion Matrix:
[[116 30]
[ 46 39]]
Classification Report:
            precision   recall   f1-score    support
      0       0.72      0.79       0.75     146
      1       0.57      0.46       0.51     85
micro avg     0.67      0.67       0.67     231
macro avg     0.64      0.63       0.63     231
weighted avg  0.66      0.67       0.66     231

Accuracy: 0.670995670995671

Visualizing Decision Tree

可以使用以下代码对上述决策树进行可视化——

from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO
from IPython.display import Image
import pydotplus

dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,
      filled=True, rounded=True,
      special_characters=True,feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_png('Pima_diabetes_Tree.png')
Image(graph.create_png())

Classification Algorithms - Naïve Bayes

Introduction to Naïve Bayes Algorithm

朴素贝叶斯算法是一种分类技术，它基于应用贝叶斯定理，并且有一个强假设，即所有预测变量都相互独立。简而言之，假设是类别中特征的存在独立于同一类别中任何其他特征的存在。例如，如果手机有触摸屏、便携功能、好的摄像头等，它可以被认为是智能的。尽管所有这些特性是相互依赖的，但它们会独立地影响该手机是智能手机的概率。

在贝叶斯分类中，主要目的是找到后验概率，即给定某些观察到的特征的标签概率，P(L | fatures)。借助贝叶斯定理，我们可以将其定量表示如下−

此处，P(L | fatures) 是类的后验概率。

P(L) 是类的先验概率。

P(fatures | L) 是可能性，即给定类的预测变量的概率。

P(fatures) 是预测变量的先验概率。

Building model using Naïve Bayes in Python

Python 库 Scikit learn 是帮助我们在 Python 中构建朴素贝叶斯模型的最有用的库。我们可以在 Scikit learn Python 库中找到以下三种类型的朴素贝叶斯模型−

Gaussian Naïve Bayes

它是最简单的朴素贝叶斯分类器，假设来自每个标签的数据都是从一个简单的正态分布中获取的。

Multinomial Naïve Bayes

另一个有用的朴素贝叶斯分类器是多项式朴素贝叶斯，其中假设特征是从一个简单的多项式分布中获取的。这种朴素贝叶斯最适合表示离散计数的特征。

Bernoulli Naïve Bayes

另一个重要的模型是伯努利朴素贝叶斯，其中假设特征是二进制的（0 和 1）。用“词袋”模型进行文本分类可以成为伯努利朴素贝叶斯的应用。

Example

根据我们的数据集，我们可以选择上面解释的任何朴素贝叶斯模型。在这里，我们在 Python 中实现高斯朴素贝叶斯模型−

我们将从所需导入开始，如下所示−

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()

现在，通过使用 Scikit learn 的 make_blobs() 函数，我们可以生成具有正态分布的点团，如下所示−

from sklearn.datasets import make_blobs
X, y = make_blobs(300, 2, centers=2, random_state=2, cluster_std=1.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');

接下来，为了使用 GaussianNB 模型，我们需要导入它并使其成为对象，如下所示−

from sklearn.naive_bayes import GaussianNB
model_GBN = GaussianNB()
model_GNB.fit(X, y);

现在，我们必须进行预测。它可以在生成一些新数据后按照以下步骤进行 −

rng = np.random.RandomState(0)
Xnew = [-6, -14] + [14, 18] * rng.rand(2000, 2)
ynew = model_GNB.predict(Xnew)

接下来，我们要绘制新数据以找到它的边界 −

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
lim = plt.axis()
plt.scatter(Xnew[:, 0], Xnew[:, 1], c=ynew, s=20, cmap='summer', alpha=0.1)
plt.axis(lim);

现在，借助以下代码行，我们可以找到第一个和第二个标签的后验概率 −

yprob = model_GNB.predict_proba(Xnew)
yprob[-10:].round(3)

Output

array([[0.998, 0.002],
      [1. , 0. ],
      [0.987, 0.013],
      [1. , 0. ],
      [1. , 0. ],
      [1. , 0. ],
      [1. , 0. ],
      [1. , 0. ],
      [0. , 1. ],
      [0.986, 0.014]])

Pros & Cons

Pros

以下是使用朴素贝叶斯分类器的一些优点 −

朴素贝叶斯分类易于实现且速度快。
它的收敛速度比逻辑回归等判别模型更快。
它需要的训练数据更少。
它本质上具有高度可伸缩性，或者它们随预测器和数据点的数量线性扩展。
它可以进行概率预测，并且可以处理连续数据和离散数据。
朴素贝叶斯分类算法可以用于二元分类和多类分类问题。

Cons

以下是使用朴素贝叶斯分类器的一些缺点 −

朴素贝叶斯分类最重要的缺点之一是其强大的特征独立性，因为在现实生活中几乎不可能拥有一组完全独立于彼此的特征。
朴素贝叶斯分类的另一个问题是它的“零频率”，这意味着如果一个分类变量有一个类别，但在训练数据集中没有被观测到，则朴素贝叶斯模型会给它分配一个零概率，并且它将无法做出预测。

Applications of Naïve Bayes classification

以下是朴素贝叶斯分类的一些常见应用程序 −

Real-time prediction − 由于易于实现和快速计算，它可用于进行实时预测。

Multi-class prediction − 朴素贝叶斯分类算法可用于预测目标变量的多个类的后验概率。

Text classification − 由于多类预测的特性，朴素贝叶斯分类算法非常适合文本分类。这就是它也用于解决垃圾邮件过滤和情绪分析等问题的原因。

Recommendation system − 除了协同过滤等算法之外，朴素贝叶斯还构成一个推荐系统，该系统可用于过滤未见信息并预测用户是否会喜欢给定的资源。

Classification Algorithms - Random Forest

Introduction

随机森林是一种监督学习算法，用于分类和回归。但它主要用于分类问题。我们知道森林是由树木组成的，树越多，森林就越健壮。同样，随机森林算法针对数据样本创建决策树，然后从每个决策树中获取预测，最后通过投票方式选择最佳解决方案。它是一种集成方法，优于单个决策树，因为它通过平均结果来减少过度拟合。

Working of Random Forest Algorithm

借助以下步骤，我们可以了解随机森林算法的工作原理：

Step1 ——首先，从给定数据集中开始选择随机样本。

Step2 ——接下来，此算法将为每个样本构建一个决策树。然后，它将从每个决策树中获取预测结果。

Step3 ——在此步骤中，将对每个预测结果执行投票。

Step4 ——最后，选择票数最多的预测结果作为最终的预测结果。

以下图表将说明其工作原理——

Implementation in Python

首先，从导入必要的 Python 包开始——

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

接下来，从其 Web 链接下载 iris 数据集，如下所示——

path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

接下来，我们需要按照以下方式为数据集分配列名称 −

headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

现在，我们需要按照以下方式将数据集读入 Pandas 数据框 −

dataset = pd.read_csv(path, names=headernames)
dataset.head()


sepal-length
sepal-width
petal-length
petal-width
Class
0
5.1
3.5
1.4
0.2
Iris-setosa
1
4.9
3.0
1.4
0.2
Iris-setosa
2
4.7
3.2
1.3
0.2
Iris-setosa
3
4.6
3.1
1.5
0.2
Iris-setosa
4
5.0
3.6
1.4
0.2
Iris-setosa

数据预处理将借助以下脚本行执行 −

X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values

接下来，我们将数据分为训练和测试拆分。以下代码将数据集拆分为 70% 的训练数据和 30% 的测试数据——

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)

接下来，使用 sklearn 的 RandomForestClassifier 类按照以下方式训练模型 −

from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators=50)
classifier.fit(X_train, y_train)

最后，我们需要进行预测。可以借助以下脚本执行此操作 −

y_pred = classifier.predict(X_test)

接下来，按照以下方式打印结果 −

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

Output

Confusion Matrix:
[[14 0 0]
[ 0 18 1]
[ 0 0 12]]
Classification Report:
               precision       recall     f1-score       support
Iris-setosa        1.00         1.00        1.00         14
Iris-versicolor    1.00         0.95        0.97         19
Iris-virginica     0.92         1.00        0.96         12
micro avg          0.98         0.98        0.98         45
macro avg          0.97         0.98        0.98         45
weighted avg       0.98         0.98        0.98         45

Accuracy: 0.9777777777777777

Pros and Cons of Random Forest

Pros

以下是 Random Forest 算法的优点 −

它通过对不同的决策树的结果进行平均或组合来克服过拟合的问题。
与单个决策树相比，随机森林适用于范围更广的数据项。
随机森林的方差小于单个决策树。
随机森林非常灵活且具有非常高的准确性。
随机森林算法不需要对数据进行缩放。即使在不缩放的情况下提供数据，它也能保持良好的准确性。
随机森林算法不需要对数据进行缩放。即使在不缩放的情况下提供数据，它也能保持良好的准确性。

Cons

以下是 Random Forest 算法的缺点 −

复杂度是 Random forest 算法的主要缺点。
与决策树相比，构建 Random forest 困难得多且耗时。
实现 Random Forest 算法需要更多的计算资源。
如果我们有大量决策树，它不太直观。
与其他算法相比，使用随机森林进行预测非常耗时。

Regression Algorithms - Overview

Introduction to Regression

回归是另一个重要且广泛使用的统计和机器学习工具。基于回归的任务的主要目标是为给定的输入数据预测输出标签或响应，这些输出标签或响应是连续数值。输出将基于模型在训练阶段中学习到的内容。基本上，回归模型使用输入数据特征（自变量）及其相应的连续数值输出值（因变量或结果变量）来学习输入和相应输出之间的特定关联。

Types of Regression Models

回归模型分为以下两类：

Simple regression model - 这是最基本的回归模型，其中预测是从数据的单一单变量特征形成的。

Multiple regression model - 正如名称所示，在此回归模型中，预测是从数据的多个特征形成的。

Building a Regressor in Python

Python 中的回归模型的构造方式与分类器的构造方式相同。Scikit-learn 是一个用于机器学习的 Python 库，还可以用于在 Python 中构建回归模型。

在以下示例中，我们将构建一个基本的回归模型，它将拟合一条数据线，即线性回归模型。在 Python 中构建回归模型所需的步骤如下：

Step1: Importing necessary python package

要使用 scikit-learn 构建回归模型，我们需要导入它以及其他必需的包。我们可以使用以下脚本导入：

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

Step2: Importing dataset

在导入必要的包之后，我们需要一个数据集来构建回归预测模型。我们可以从 sklearn 数据集中导入它，也可以根据我们的需求使用其他数据集。我们将使用保存的输入数据。我们可以借助以下脚本导入：

input = r'C:\linear.txt'

接下来，我们需要加载此数据。我们使用 np.loadtxt 函数来加载它。

input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]

Step3: Organizing data into training & testing sets

由于我们需要在未见数据上测试我们的模型，因此我们将数据集分为两部分：训练集和测试集。以下命令将执行此操作：

training_samples = int(0.6 * len(X))
testing_samples = len(X) - num_training

X_train, y_train = X[:training_samples], y[:training_samples]

X_test, y_test = X[training_samples:], y[training_samples:]

Step4- Model evaluation & prediction

在将数据划分为训练和测试后，我们需要构建模型。我们将为此目的使用 Scikit-learn 的 LineaRegression() 函数。以下命令将创建一个线性回归对象。

reg_linear= linear_model.LinearRegression()

接下来，使用训练样本训练此模型，如下所示：

reg_linear.fit(X_train, y_train)

现在，最后我们需要使用测试数据进行预测了。

y_test_pred = reg_linear.predict(X_test)

Step5- Plot & visualization

预测之后，我们可以借助以下脚本绘制并对其进行可视化：

plt.scatter(X_test, y_test, color='red')
plt.plot(X_test, y_test_pred, color='black', linewidth=2)
plt.xticks(())
plt.yticks(())
plt.show()

Output

在上面的输出中，我们可以在数据点之间看到回归线。

Step6- Performance computation − 我们还可以借助以下各种性能指标来计算回归模型的性能 −

print("Regressor model performance:")
print("Mean absolute error(MAE) =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error(MSE) =", round(sm.mean_squared_error(y_test, y_test_pred), 2))
print("Median absolute error =", round(sm.median_absolute_error(y_test, y_test_pred), 2))
print("Explain variance score =", round(sm.explained_variance_score(y_test, y_test_pred), 2))
print("R2 score =", round(sm.r2_score(y_test, y_test_pred), 2))

Output

Regressor model performance:
Mean absolute error(MAE) = 1.78
Mean squared error(MSE) = 3.89
Median absolute error = 2.01
Explain variance score = -0.09
R2 score = -0.09

Types of ML Regression Algorithms

最有用的流行 ML 回归算法是线性回归算法，它进一步分为两类：

Simple Linear Regression algorithm
Multiple Linear Regression algorithm.

我们将在下一章中对其进行讨论并在 Python 中实现它。

Applications

ML 回归算法的应用如下：

Forecasting or Predictive analysis - 回归的一个重要用途是预测或预测分析。例如，我们可以预测 GDP、石油价格或简单来说随着时间的推移而变化的数量化数据。

Optimization − 我们可以在回归的帮助下优化业务流程。例如，商店经理可以创建统计模型以了解顾客高峰期。

Error correction − 在业务中，做出正确的决定与优化业务流程一样重要。回归可以帮助我们做出正确的决定，并帮助纠正在已执行的决策。

Economics − 这是经济学中最常用的工具。我们可以使用回归来预测供给、需求、消费、库存投资等。

Finance − 金融公司始终对最大程度降低风险组合感兴趣，并且想知道影响客户的因素。所有这些都可以使用回归模型进行预测。

Regression Algorithms - Linear Regression

Introduction to Linear Regression

线性回归可以定义为分析因变量与给定的一组自变量之间的线性关系的统计模型。变量之间的线性关系意味着当一个或多个自变量的值变化（增加或减少）时，因变量的值也会相应地发生变化（增加或减少）。

在数学上，可以通过以下等式来表示这种关系 −

Y = mX + b

其中，Y 是我们尝试预测的因变量

X 是我们用于进行预测的自变量。

m 是回归线的斜率，表示 X 对 Y 的影响。

b 是一个常量，称为 Y 截距。如果 X = 0，则 Y 等于 b。

此外，线性关系的本质可以是正面的或负面的，如下所述 −

Positive Linear Relationship

如果自变量和因变量均增加，则线性关系将称为正相关关系。可以通过以下图形来理解这一点 −

Negative Linear relationship

如果自变量增加而因变量减小，则线性关系将称为正相关关系。可以通过以下图形来理解这一点 −

Types of Linear Regression

线性回归具有以下两种类型 −

Simple Linear Regression
Multiple Linear Regression

Simple Linear Regression (SLR)

它是线性回归的最基本版本，它使用单个特征预测响应。SLR 中的假设是这两个变量是线性相关的。

Python implementation

我们可以用两种方法在 Python 中实现 SLR，一种是提供你自己的数据集，另一种是从 scikit-learn python 库中使用数据集。

Example1 − 在以下 Python 实现示例中，我们使用我们自己的数据集。

首先，我们将从导入必要包开始，如下所示 −

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

接下来，定义一个将计算 SLR 重要值的函数 −

def coef_estimation(x, y):

以下脚本行将给出观测值 n −

n = np.size(x)

x 和 y 向量的平均值可以按如下方式计算 −

m_x, m_y = np.mean(x), np.mean(y)

我们可以按如下方式找到交叉差和围绕 x 的差 −

SS_xy = np.sum(y*x) - n*m_y*m_x
SS_xx = np.sum(x*x) - n*m_x*m_x

接下来，回归系数即 b 可按如下方式计算 −

b_1 = SS_xy / SS_xx
b_0 = m_y - b_1*m_x
return(b_0, b_1)

接下来，我们需要定义一个函数，它将绘制回归线并预测响应矢量 −

def plot_regression_line(x, y, b):

以下脚本行将绘制实际点作为散点图 −

plt.scatter(x, y, color = "m", marker = "o", s = 30)

以下脚本行将预测响应矢量 −

y_pred = b[0] + b[1]*x

以下脚本行将绘制回归线并在其上放置标签 −

plt.plot(x, y_pred, color = "g")
plt.xlabel('x')
plt.ylabel('y')
plt.show()

最后，我们需要定义 main() 函数，用于提供数据集并调用我们上面定义的函数 −

def main():
   x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
   y = np.array([100, 300, 350, 500, 750, 800, 850, 900, 1050, 1250])
   b = coef_estimation(x, y)
   print("Estimated coefficients:\nb_0 = {} \nb_1 = {}".format(b[0], b[1]))
   plot_regression_line(x, y, b)

if __name__ == "__main__":
main()

Output

Estimated coefficients:
b_0 = 154.5454545454545
b_1 = 117.87878787878788

Example2 − 在下面的 Python 实施示例中，我们正在使用 scikit-learn 中的糖尿病数据集。

首先，我们将从导入必要包开始，如下所示 −

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score

接下来，我们将加载糖尿病数据集并创建其对象 −

diabetes = datasets.load_diabetes()

由于我们实施了 SLR，我们将仅使用一项功能，如下所示 −

X = diabetes.data[:, np.newaxis, 2]

接下来，我们需要将数据分成训练和测试集，如下所示 −

X_train = X[:-30]
X_test = X[-30:]

接下来，我们需要将目标分成训练和测试集，如下所示 −

y_train = diabetes.target[:-30]
y_test = diabetes.target[-30:]

现在，要训练模型，我们需要创建如下所示的线性回归对象 −

regr = linear_model.LinearRegression()

接下来，使用训练集训练模型，如下所示 −

regr.fit(X_train, y_train)

接下来，使用测试集进行预测，如下所示 −

y_pred = regr.predict(X_test)

接下来，我们将打印一些系数，例如 MSE、方差分数等，如下所示 −

print('Coefficients: \n', regr.coef_)
print("Mean squared error: %.2f"
   % mean_squared_error(y_test, y_pred))
print('Variance score: %.2f' % r2_score(y_test, y_pred))

现在，绘制输出内容，如下所示 −

plt.scatter(X_test, y_test, color='blue')
plt.plot(X_test, y_pred, color='red', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

Output

Coefficients:
   [941.43097333]
Mean squared error: 3035.06
Variance score: 0.41

Multiple Linear Regression (MLR)

这是简单线性回归的扩展，它使用两个或更多特征来预测响应。在数学上，我们可以解释如下 −

考虑一个具有 n 个观测值、p 个特征（即自变量）和 y 作为响应（即因变量）的数据集线性回归线对于 p 个特征可以计算如下 −

其中，h(xi) 是预测的响应值，b0、b1、b2â€¦、bp 是回归系数。

多元线性回归模型始终包含称为残差误差的数据误差，该误差会更改计算，如下所示 −

我们还可以将上述方程式写成以下形式 −

Python Implementation

在此示例中，我们将使用 scikit learn 的波士顿住房数据集 −

首先，我们将从导入必要包开始，如下所示 −

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, metrics

接下来，加载数据集，如下所示 −

boston = datasets.load_boston(return_X_y=False)

以下脚本行将定义特征矩阵 X 和响应向量 Y −

X = boston.data
y = boston.target

接下来，将数据集分成训练和测试集，如下所示 −

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.7, random_state=1)

现在，创建线性回归对象并训练模型，如下所示 −

reg = linear_model.LinearRegression()
reg.fit(X_train, y_train)
print('Coefficients: \n', reg.coef_)
print('Variance score: {}'.format(reg.score(X_test, y_test)))
plt.style.use('fivethirtyeight')
plt.scatter(reg.predict(X_train), reg.predict(X_train) - y_train,
      color = "green", s = 10, label = 'Train data')
plt.scatter(reg.predict(X_test), reg.predict(X_test) - y_test,
      color = "blue", s = 10, label = 'Test data')
plt.hlines(y = 0, xmin = 0, xmax = 50, linewidth = 2)
plt.legend(loc = 'upper right')
plt.title("Residual errors")
plt.show()

Output

Coefficients:
[-1.16358797e-01 6.44549228e-02 1.65416147e-01 1.45101654e+00
-1.77862563e+01 2.80392779e+00 4.61905315e-02 -1.13518865e+00
3.31725870e-01 -1.01196059e-02 -9.94812678e-01 9.18522056e-03
-7.92395217e-01]
Variance score: 0.709454060230326

Assumptions

以下是线性回归模型对数据集所做的一些假设 −

Multi-collinearity − 线性回归模型假设数据中几乎没有或没有多重共线性。基本上，当自变量或特征其中有依赖关系时，就会出现多重共线性。

Auto-correlation − 线性回归模型的另一项假设是数据中几乎没有或没有自相关。基本上，当残差误差之间存在依赖关系时，就会出现自相关。

Relationship between variables − 线性回归模型假设响应变量和特征变量之间的关系必须是线性的。

Clustering Algorithms - Overview

Introduction to Clustering

聚类方法是最有用的无监督 ML 方法之一。这些方法用于查找数据样本之间的相似性以及关系模式，然后将这些样本聚类到基于特征相似性的组中。

聚类很重要，因为它确定了当前未标记数据之间的内在分组。它们在基本上对数据点做出了一些关于其相似性的假设。每一项假设都会构建不同但同样有效的聚类。

例如，以下是显示聚类系统将不同聚类中相似类型的数据分组在一起的图表：

Cluster Formation Methods

聚类不必以球形形式形成。以下是一些其他聚类形成方法：

Density-based

在这些方法中，聚类被形成为稠密区域。这些方法的优点在于，它们既具有良好的准确性，又有合并两个聚类的良好能力。例如，带噪声的基于密度的空间聚类应用 (DBSCAN)，用于识别聚类结构的排序点 (OPTICS) 等。

Hierarchical-based

在这些方法中，聚类被基于分层形成为树型结构。它们有两个类别，即凝聚（自底向上的方法）和分裂（自顶向下的方法）。例如，使用代表的聚类 (CURE)，使用层次结构的平衡迭代缩小聚类 (BIRCH) 等。

Partitioning

在这些方法中，聚类是由将各个对象分配到 k 个聚类中而形成的。聚类数将等于分区数。例如，K 均值，基于随机搜索聚类大型应用程序 (CLARANS)。

Grid

在这些方法中，聚类被形成为网格状结构。这些方法的优点在于，在这些网格上进行的所有聚类操作都很快，并且与数据对象的数量无关。例如，统计信息网格 (STING)，寻求聚类 (CLIQUE)。

Measuring Clustering Performance

有关 ML 模型最重要的考虑因素之一是评估其性能或可以称之为模型的质量。在监督学习算法的情况下，对模型质量的评估很简单，因为我们已经为每个示例都贴上了标签。

另一方面，在无监督学习算法的情况下，由于我们处理的是未标记数据，因此我们没有那么幸运。但我们仍然有一些指标可以让从业者深入了解群集的变化，具体取决于算法。

在我们深入了解这些指标之前，我们必须了解这些指标只是评估模型之间的比较性能，而不是衡量模型预测的有效性。以下是我们可以在聚类算法中部署的一些指标来衡量模型质量 -

Silhouette Analysis

轮廓分析用于检查聚类模型的质量，方法是测量聚类之间的距离。它基本上为我们提供了一种方法来评估聚类数量等参数，这得益于 Silhouette score 。此分数衡量一个聚类中的每个点与相邻聚类中的点的距离。

Analysis of Silhouette Score

轮廓分数的范围为 [-1, 1]。它的分析如下 -

+1 Score − 在 +1 Silhouette score 附近指示样本远离其相邻聚类。
0 Score − 0 Silhouette score 表示样本位于或非常靠近分隔两个相邻聚类的决策边界。
-1 Score &minusl -1 Silhouette score 表示已将样本分配到错误的聚类。

轮廓分数的计算可以使用以下公式进行 −

silhouette 分数=(p-q)/max (p,q)

此处，p = 到最近聚类中点的平均距离

并且，q = 到所有点的平均聚类内距离。

Davis-Bouldin Index

DB 索引是执行聚类算法分析的另一个好指标。借助 DB 索引，我们可以了解有关聚类模型的以下几点 -

聚类是否彼此相距较远？
聚类有多密集？

我们可以借助以下公式计算 DB 索引 -

此处，n = 聚类数

σi = 聚类 i 中所有点到聚类质心 ci 的平均距离。

DB 索引越少，聚类模型越好。

Dunn Index

它的工作原理与 DB 索引相同，但有以下几点不同：

Dunn 索引仅考虑最坏的情况，即彼此接近的簇，而 DB 索引则考虑聚类模型中所有簇的分散和分离。
Dunn 索引会随着性能的提高而增大，而 DB 索引则会在簇分布均匀且密集时变得更好。

我们可以借助以下公式计算 Dunn 索引：

其中，𝑖,𝑗,𝑘 = 每个簇的索引

𝑝 = 簇间距离

q = 簇内距离

Types of ML Clustering Algorithms

以下是最重要的有用的 ML 聚类算法 −

K-means Clustering

此聚类算法计算质心并迭代直至找到最佳质心。它假定已知聚类数。它也被称为平面聚类算法。算法从数据识别的聚类数在 K 均值中表示为“K”。

Mean-Shift Algorithm

这是无监督学习中使用的另一种强有力的聚类算法。与 K 均值聚类不同，它不作任何假设，因此它是一种非参数算法。

Hierarchical Clustering

这是另一种无监督学习算法，用于对具有相似特征的未标记数据点进行分组。

我们将在接下来的章节中详细讨论所有这些算法。

Applications of Clustering

我们可以在以下领域发现聚类很有用 −

Data summarization and compression − 聚类被广泛用于我们要求数据汇总、压缩和减少的领域。例如图像处理和矢量量化。

Collaborative systems and customer segmentation − 由于聚类可以用于查找类似产品或同类用户，因此它可以用于协作系统和客户细分领域。

Serve as a key intermediate step for other data mining tasks − 聚类分析可以生成用于分类、测试、假设生成的数据的紧凑摘要；因此，它也作为其他数据挖掘任务的关键中间步骤。

Trend detection in dynamic data − 通过创建具有类似趋势的不同聚类，聚类还可以用于动态数据中的趋势检测。

Social network analysis − 聚类可以用于社交网络分析。例如，在图像、视频或音频中生成序列。

Biological data analysis − 聚类还可以用于生成图像和视频聚类，因此可以成功地用于生物数据分析。

Clustering Algorithms - K-means Algorithm

Introduction to K-Means Algorithm

K-means 聚类算法计算质心并迭代，直到找到最优质心。它假设已知集群数。它也被称为 flat clustering 算法。k-means 中算法通过数据识别的集群数由“K”表示。

此算法中，数据点被分配给一个集群，数据点和质心之间的平方距离总和将达到最小值。可以理解的是，集群内方差越小，同一集群内的数据点越相似。

Working of K-Means Algorithm

我们可借助以下步骤理解 K 均值聚类算法的工作原理：

Step1 - 首先，我们需要指定算法需要生成的集群数量 K。

Step2 - 接下来，随机选取 K 个数据点，并将每个数据点分配给一个集群。简而言之，根据数据点的数量对数据进行分类。

Step3 - 现在，算法将计算聚类质心。

Step4 - 接下来，不断迭代以下步骤，直至找到最优质心，即将数据点分配给不再发生变化的集群：

4.1 - 首先，计算数据点和质心之间的平方距离之和。

4.2 - 现在，我们需要将每个数据点分配给比其他集群（质心）更近的集群。

4.3 - 最后，通过取该集群内的所有数据点的平均值来计算此集群的质心。

K 均值采用 Expectation-Maximization 方法来解决问题。期望步用于将数据点分配给最接近的集群，最大化步用于计算每个集群的质心。

使用 K 均值算法时，我们需要注意以下事项：

使用包括 K 均值在内的聚类算法时，建议对数据进行标准化，因为此类算法使用基于距离的测量来确定数据点之间的相似性。
由于 K 均值的迭代性质和质心的随机初始化，K 均值可能会停留在局部最优，并且可能无法收敛到全局最优。因此，建议使用不同的质心初始化。

Implementation in Python

用于实现 K 均值聚类算法的以下两个示例将有助于我们更好地理解此算法：

Example1

这是一个简单的示例，用于理解 k 均值的工作方式。在此示例中，我们将首先生成包含 4 个不同斑点的 2D 数据集，然后应用 k 均值算法来查看结果。

首先，我们将通过导入必要的包来开始：

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

以下代码将生成包含 4 个斑点的 2D：

from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4, cluster_std=0.60, random_state=0)

接下来，以下代码将帮助我们可视化数据集：

plt.scatter(X[:, 0], X[:, 1], s=20);
plt.show()

接下来，创建一个 KMeans 对象并同时提供集群数量，训练模型并进行预测，如下所示：

kmeans = KMeans(n_clusters=4)
kmeans.fit(X)
y_kmeans = kmeans.predict(X)

现在，在以下代码的帮助下，我们可以绘制并可视化均值 k-Means Python 估计器选择的集群中心−

plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=20, cmap='summer')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='blue', s=100, alpha=0.9);
plt.show()

Example 2

让我们切换到另一个示例，其中我们将对简单的数字数据集应用 K-Means 集群。K-Means 将尝试识别类似数字，而不使用原始标签信息。

首先，我们将通过导入必要的包来开始：

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

接下来，从 sklearn 中加载数字数据集并生成一个对象。我们还可以在此数据集中找到行数和列数，如下所示 -

from sklearn.datasets import load_digits
digits = load_digits()
digits.data.shape

Output

(1797, 64)

以上输出表明，此数据集包含 1797 个样本，具有 64 个特征。

我们可以如以上示例 1 中所述执行集群 −

kmeans = KMeans(n_clusters=10, random_state=0)
clusters = kmeans.fit_predict(digits.data)
kmeans.cluster_centers_.shape

Output

(10, 64)

以上输出表明，K-Means 创建了 10 个集群，具有 64 个特征。

fig, ax = plt.subplots(2, 5, figsize=(8, 3))
centers = kmeans.cluster_centers_.reshape(10, 8, 8)
for axi, center in zip(ax.flat, centers):
   axi.set(xticks=[], yticks=[])
   axi.imshow(center, interpolation='nearest', cmap=plt.cm.binary)

Output

作为输出，我们将获得以下图像，显示 k-means 了解的集群中心。

以下代码行将匹配了解的集群标签和在其中找到的真实标签 -

from scipy.stats import mode
labels = np.zeros_like(clusters)
for i in range(10):
   mask = (clusters == i)
   labels[mask] = mode(digits.target[mask])[0]

接下来，我们可以按如下方式检查精确度 -

from sklearn.metrics import accuracy_score
accuracy_score(digits.target, labels)

Output

0.7935447968836951

以上输出表明，精确度约为 80%。

Advantages and Disadvantages

Advantages

以下是 K-Means 集群算法的一些优点 −

它很容易理解和实施。
如果我们有大量变量，那么 K-Means 将比层次集群更快。
在重新计算质心时，一个实例可以改变集群。
与层次集群相比，K-Means 形成更紧密的集群。

Disadvantages

以下是 K-Means 集群算法的一些缺点 −

预测集群数即 k 的值有点困难。
输出受到初始输入（如集群数（k 的值））的强烈影响。
数据顺序将对最终输出产生重大影响。
对缩放非常敏感。如果我们通过归一化或标准化方法重新缩放数据，那么输出将完全改变。最终结果。
如果群集具有复杂的几何形状，则在执行群集作业中效果不佳。

Applications of K-Means Clustering Algorithm

聚类分析的主要目标为 -

从我们正在使用的数据中获得有意义的直觉。
构建不同子群不同模型的群集然后预测。

为了实现上述目标，K 均值聚类表现得足够好。它可以用于以下应用中 -

Market segmentation
Document Clustering
Image segmentation
Image compression
Customer segmentation
分析动态数据的趋势

Clustering Algorithms - Mean Shift Algorithm

Introduction to Mean-Shift Algorithm

如前所述，这是无监督学习中使用的另一种强大的聚类算法。不同于 K 均值聚类，它不做出任何假设；因此它是一种非参数化算法。

均值漂移算法通过将点向数据点密度最高处（即群集质心）偏移，基本将数据点迭代分配到群集中。

K 均值算法和均值漂移算法之间的区别在于后者不需要预先指定群集数，因为群集数将由算法相对于数据确定。

Working of Mean-Shift Algorithm

我们可以借助以下步骤了解均值漂移聚类算法的工作原理 -

Step1 - 首先，从分配给它们自己的群集的数据点开始。

Step2 - 接下来，此算法将计算质心。

Step3 - 在此步骤中，将更新新质心的位置。

Step4 - 现在，将迭代该过程并移动到更高密度区域。

Step5 - 最后，当质心达到无法再移动的位置时，它将停止。

Implementation in Python

这是一个简单的示例，用于了解均值漂移算法的工作原理。在此示例中，我们将首先生成包含 4 个不同斑点的 2D 数据集，然后应用均值漂移算法查看结果。

%matplotlib inline
import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")
from sklearn.datasets.samples_generator import make_blobs
centers = [[3,3,3],[4,5,5],[3,10,10]]
X, _ = make_blobs(n_samples = 700, centers = centers, cluster_std = 0.5)
plt.scatter(X[:,0],X[:,1])
plt.show()

ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
colors = 10*['r.','g.','b.','c.','k.','y.','m.']
for i in range(len(X)):
   plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 3)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
      marker=".",color='k', s=20, linewidths = 5, zorder=10)
plt.show()

输出

[[ 2.98462798 9.9733794 10.02629344]
[ 3.94758484 4.99122771 4.99349433]
[ 3.00788996 3.03851268 2.99183033]]
Estimated clusters: 3

Advantages and Disadvantages

Advantages

以下是均值漂移聚类算法的一些优点 -

它不需要像 K 均值或高斯混合那样做出任何模型假设。
它还可以对具有非凸形状的复杂簇建模。
它只需要一个名为带宽的参数，该参数会自动确定簇的数量。
没有像 K 均值中的局部最小值的问题。
不会出现异常值生成的问题。

Disadvantages

以下是均值漂移聚类算法的一些缺点 -

在高维度（其中簇的数量急剧变化）的情况下，均值漂移算法无法很好地工作。

我们无法直接控制簇的数量，但在某些应用程序中，我们需要具体数量的簇。
它无法区分有意义和无意义的模式。

Clustering Algorithms - Hierarchical Clustering

Introduction to Hierarchical Clustering

层次聚类是另一种无监督学习算法，用于将具有相似特征的未标记数据点分组在一起。层次聚类算法分为以下两类：

Agglomerative hierarchical algorithms − 在凝聚层次算法中，每个数据点都被视为一个单一簇，然后依次合并或凝聚（自下而上方法）簇对。簇的层次结构表示为树状图或树结构。

Divisive hierarchical algorithms − 另一方面，在分裂层次算法中，所有数据点都被视为一个大簇，而聚类过程涉及将一个大簇分割（自上而下方法）为多个小簇。

Steps to Perform Agglomerative Hierarchical Clustering

我们将解释最常用、最重要的层次聚类，即凝聚。执行此操作的步骤如下 −

Step1 - 将每个数据点视为单个群集。因此，我们将从开始就有 K 个簇。数据点的数量在开始时也将是 K。

Step2 - 现在，在此步骤中，我们需要通过连接两个最接近的数据点来形成一个大簇。这将产生总共 K-1 个簇。

Step3 - 现在，为了形成更多簇，我们需要连接两个最接近的簇。这将产生总共 K-2 个簇。

Step4 - 现在，要形成一个大簇，重复上述三个步骤，直到 K 变为 0，即没有更多数据点可以加入。

Step5 - 最后，在制作了一个大簇之后，将使用树状图根据问题将其划分为多个簇。

Role of Dendrograms in Agglomerative Hierarchical Clustering

如我们在上一步中所讨论的，一旦形成了大簇，树状图的作用就开始了。树状图将用于根据我们的问题将簇分割为多个相关数据点的簇。我们可以借助以下示例来理解：

Example1

为了理解，让我们开始导入所需的库，如下所示：

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

接下来，我们将绘制我们为此示例获取的数据点 −

X = np.array([[7,8],[12,20],[17,19],[26,15],[32,37],[87,75],[73,85], [62,80],[73,60],[87,96],])
labels = range(1, 11)
plt.figure(figsize=(10, 7))
plt.subplots_adjust(bottom=0.1)
plt.scatter(X[:,0],X[:,1], label='True Position')
for label, x, y in zip(labels, X[:, 0], X[:, 1]):
   plt.annotate(label,xy=(x, y), xytext=(-3, 3),textcoords='offset points', ha='right', va='bottom')
plt.show()

从上图中，很容易看出，我们的数据点中有两个簇，但实际数据中有可能是数千个簇。接下来，我们将使用 SciPy 库绘制我们的数据点的树状图：

from scipy.cluster.hierarchy import dendrogram, linkage
from matplotlib import pyplot as plt
linked = linkage(X, 'single')
labelList = range(1, 11)
plt.figure(figsize=(10, 7))
dendrogram(linked, orientation='top',labels=labelList, distance_sort='descending',show_leaf_counts=True)
plt.show()

现在，在大簇形成后，将选择最长的垂直距离。然后在其周围绘制一条垂直线，如下图所示。由于水平线在两点处穿过蓝线，因此簇的数量将是两个。

接下来，我们需要导入用于聚类的类，并调用它的 fit_predict 方法来预测簇。我们导入的是 sklearn.cluster 库的 AgglomerativeClustering 类：

from sklearn.cluster import AgglomerativeClustering
cluster = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')
cluster.fit_predict(X)

接下来，使用以下代码绘制簇 −

plt.scatter(X[:,0],X[:,1], c=cluster.labels_, cmap='rainbow')

上图显示了我们数据点中的两个簇。

Example2

如我们从上面讨论的简单示例中了解到的树状图概念，让我们转到另一个示例，其中我们使用层次聚类创建了 Pima Indian Diabetes 数据集中数据点的簇：

import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline
import numpy as np
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
data.shape
(768, 9)
data.head()

slno.	preg	Plas	Pres	skin	test	mass	pedi	age	class
0	6	148	72	35	0	33.6	0.627	50	1
1	1	85	66	29	0	26.6	0.351	31	0
2	8	183	64	0	0	23.3	0.672	32	1
3	1	89	66	23	94	28.1	0.167	21	0
4	0	137	40	35	168	43.1	2.288	33	1

patient_data = data.iloc[:, 3:5].values
import scipy.cluster.hierarchy as shc
plt.figure(figsize=(10, 7))
plt.title("Patient Dendograms")
dend = shc.dendrogram(shc.linkage(data, method='ward'))

from sklearn.cluster import AgglomerativeClustering
cluster = AgglomerativeClustering(n_clusters=4, affinity='euclidean', linkage='ward')
cluster.fit_predict(patient_data)
plt.figure(figsize=(10, 7))
plt.scatter(patient_data[:,0], patient_data[:,1], c=cluster.labels_, cmap='rainbow')

KNN Algorithm - Finding Nearest Neighbors

Introduction

K 近邻 (KNN) 算法是一种有监督的 ML 算法，可用于分类和回归预测问题。然而，它主要用于工业中的分类预测问题。以下两个特性很好地定义了 KNN -

Lazy learning algorithm - KNN 是一种延迟学习算法，因为它没有专门的训练阶段，并且在分类时使用所有数据进行训练。
Non-parametric learning algorithm - KNN 也是一种非参数学习算法，因为它不会对基础数据做任何假设。

Working of KNN Algorithm

K 近邻 (KNN) 算法使用“特征相似性”来预测新数据点的值，这意味着新的数据点将根据它与训练集中的点的匹配程度分配一个值。我们可以通过以下步骤了解它的工作原理 -

Step1 - 为了实现任何算法，我们需要数据集。因此，在 KNN 的第一步中，我们必须加载训练数据和测试数据。

Step2 - 接下来，我们需要选择 K 的值，即最近的数据点。K 可以是任何整数。

Step3 − 对于测试数据中的每个点做以下操作 −

3.1 − 借助以下任何一种方法计算测试数据与训练数据中的每一行之间的距离：欧几里德距离、曼哈顿距离或汉明距离。用于计算距离最常见的方法是欧几里德距离。

3.2 − 现在，根据距离值，按升序对它们进行排序。

3.3 − 接下来，它将从排序数组中选择前 K 行。

3.4 − 现在，它将根据这些行的最频繁类为测试点分配一个类。

Step4 − 结束

Example

以下是理解 K 的概念和 KNN 算法的工作原理的一个示例 −

假设我们有一个可以按如下方式绘制的数据集 −

现在，我们需要将带黑点的新的数据点（在点 60,60）分类为蓝色或红色类别。我们假定 K = 3，即它会找到三个最邻近的数据点。它在下一张图中显示 −

我们可以在上图中看到带黑点的这个数据点的三近邻。在这三个数据点中，有两个属于红色类别，因此黑点也将被分配到红色类别。

Implementation in Python

众所周知，K 近邻 (KNN) 算法既可以用于分类，也可以用于回归。以下是使用 Python 将 KNN 同时用作分类器和回归器的程序 −

KNN as Classifier

首先，从导入必要的 Python 包开始——

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

接下来，从其 Web 链接下载 iris 数据集，如下所示——

path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

接下来，我们需要按照以下方式为数据集分配列名称 −

headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

现在，我们需要按照以下方式将数据集读入 Pandas 数据框 −

dataset = pd.read_csv(path, names=headernames)
dataset.head()

slno.	sepal-length	sepal-width	petal-length	petal-width	Class
0	5.1	3.5	1.4	0.2	Iris-setosa
1	4.9	3.0	1.4	0.2	Iris-setosa
2	4.7	3.2	1.3	0.2	Iris-setosa
3	4.6	3.1	1.5	0.2	Iris-setosa
4	5.0	3.6	1.4	0.2	Iris-setosa

数据预处理将借助以下脚本行执行 −

X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values

接下来，我们将数据分成训练集和测试集。以下代码会将数据集分成 60% 的训练数据和 40% 的测试数据 −

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.40)

接下来，将按照如下方式对数据进行缩放 −

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

接下来，借助 sklearn 的 KNeighborsClassifier 类按如下方式训练模型 −

from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=8)
classifier.fit(X_train, y_train)

最后，我们需要进行预测。可以使用以下脚本完成——

y_pred = classifier.predict(X_test)

接下来，按照以下方式打印结果 −

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

Output

Confusion Matrix:
[[21 0 0]
[ 0 16 0]
[ 0 7 16]]
Classification Report:
            precision      recall       f1-score       support
Iris-setosa       1.00        1.00         1.00          21
Iris-versicolor   0.70        1.00         0.82          16
Iris-virginica    1.00        0.70         0.82          23
micro avg         0.88        0.88         0.88          60
macro avg         0.90        0.90         0.88          60
weighted avg      0.92        0.88         0.88          60


Accuracy: 0.8833333333333333

KNN as Regressor

首先，从导入必要的 Python 包开始——

import numpy as np
import pandas as pd

接下来，从其 Web 链接下载 iris 数据集，如下所示——

path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

接下来，我们需要按照以下方式为数据集分配列名称 −

headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

现在，我们需要按照以下方式将数据集读入 Pandas 数据框 −

data = pd.read_csv(url, names=headernames)
array = data.values
X = array[:,:2]
Y = array[:,2]
data.shape

output:(150, 5)

接下来，从 sklearn 导入 KNeighborsRegressor 以拟合模型 −

from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=10)
knnr.fit(X, y)

最后，我们可以按如下方式找到 MSE −

print ("The MSE is:",format(np.power(y-knnr.predict(X),2).mean()))

Output

The MSE is: 0.12226666666666669

Pros and Cons of KNN

Pros

这是一个理解和解释非常简单的算法。
它对非线性数据非常有用，因为该算法中没有对数据进行假设。
它是一种多功能算法，因为我们可以将它用于分类和回归。
它具有相对较高的准确度，但与 KNN 相比，还有更好的监督学习模型。

Cons

这是一种在计算上有点昂贵的算法，因为它存储了所有训练数据。
与其他监督学习算法相比，需要较高的内存存储。
当 N 较大时，预测会很慢。
它对数据的规模和无关特征非常敏感。

Applications of KNN

以下是一些 KNN 可以成功应用的领域 −

Banking System

KNN 可用于银行系统预测某个人是否适合贷款审批？此人是否具有与违约者相似的特征？

Calculating Credit Ratings

KNN 算法可用于通过与具有相似特征的人进行比较来查找个人信用评级。

Politics

借助 KNN 算法，我们可以将潜在选民分为各种类别，如“将投票”、“不会投票”、“将投票给‘国大党’”、“将投票给‘人民党’”。

KNN 算法可以应用的其他领域包括语音识别、手写检测、图像识别和视频识别。

Machine Learning - Performance Metrics

有各种指标可以用来评估 ML 算法、分类算法以及回归算法的性能。我们必须仔细选择指标来评估 ML 性能，因为 −

如何衡量和比较 ML 算法的性能完全取决于你选择什么指标。
你重视结果中各种特征的重要性将完全受到你选择指标的影响。

Performance Metrics for Classification Problems

我们在前面的章节中讨论了分类及其算法。在这里，我们将讨论可用于评价分类问题预测的各种性能指标。

Confusion Matrix

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

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

我们可以使用 sklearn.metrics 的 confusion_matrix 函数计算我们的分类模型的混淆矩阵。

Classification Accuracy

它是分类算法最常用的性能指标。它可以定义为预测的正确预测数与所做预测数之比。我们可以使用混淆矩阵轻松地根据以下公式计算它 -

我们可以使用 sklearn.metrics 的 accuracy_score 函数计算我们的分类模型的准确度。

Classification Report

此报告包括精确度、召回率、F1 和支持的分数。它们解释如下 −

Precision

精度，用于文档检索，可以定义为由我们的机器学习模型返回的正确文档数。我们可以通过以下公式借助混淆矩阵轻松计算它 -

Recall or Sensitivity

召回率可以定义为由我们的机器学习模型返回的正例数。我们可以通过以下公式借助混淆矩阵轻松计算它 -

Specificity

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

Support

支持可以定义为目标值每个类别中存在的真实响应样本数。

F1 Score

这个分数将为我们提供精确度和召回率的调和平均值。从数学角度讲，F1 分数是精确度和召回率的加权平均值。F1 的最佳值为 1，最差值为 0。我们可以借助以下公式计算 F1 分数：

F1 = 2 ∗ (精确度 ∗ 召回率) / (精确度 + 召回率)

F1 分数中包含精确度和召回率相等的相关贡献。

我们可以使用 sklearn.metrics 的 classification_report 函数获取我们分类模型的分类报告。

AUC (Area Under ROC curve)

AUC（曲线下面积）-ROC（接收者操作特征）是一种基于分类问题中变化的阈值，用于衡量其性能的指标。顾名思义，ROC 是一条概率曲线，AUC 是分离度的衡量标准。简而言之，AUC-ROC 指标将告诉我们模型区分不同类别。AUC 越大，模型也就越好。

从数学角度讲，它可以通过绘制 TPR（真阳性率），即灵敏度或召回率与 FPR（假阳性率），即 1-特异性，在各种阈值下计算得来。以下图表展示了 ROC，AUC 在 y 轴上有 TPR，在 x 轴上有 FPR：

我们可以使用 sklearn.metrics 的 roc_auc_score 函数计算 AUC-ROC。

LOGLOSS (Logarithmic Loss)

它也称为逻辑回归损失或交叉熵损失。它基本上根据概率估算定义，且衡量分类模型的性能，其中输入是一个介于 0 到 1 之间的概率值。我们可以通过将其与准确性区分开来以更清晰地理解它。众所周知，准确性是我们模型中的预测计数（预测值 = 实际值），而对数损失是我们预测的不确定程度，取决于它与实际标签的差异有多大。借助对数损失值，我们可以更准确地了解我们模型的性能。我们可以使用 sklearn. metrics 的 log_loss 函数计算对数损失。

Example

以下是 Python 中的简单示例，它将让我们深入了解如何在二元分类模型上使用上述性能指标：

from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
from sklearn.metrics import roc_auc_score
from sklearn.metrics import log_loss
X_actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
Y_predic = [1, 0, 1, 1, 1, 0, 1, 1, 0, 0]
results = confusion_matrix(X_actual, Y_predic)
print ('Confusion Matrix :')
print(results)
print ('Accuracy Score is',accuracy_score(X_actual, Y_predic))
print ('Classification Report : ')
print (classification_report(X_actual, Y_predic))
print('AUC-ROC:',roc_auc_score(X_actual, Y_predic))
print('LOGLOSS Value is',log_loss(X_actual, Y_predic))

Output

Confusion Matrix :
[[3 3]
[1 3]]
Accuracy Score is 0.6
Classification Report :
            precision      recall      f1-score       support
      0       0.75          0.50      0.60           6
      1       0.50          0.75      0.60           4
micro avg     0.60          0.60      0.60           10
macro avg     0.62          0.62      0.60           10
weighted avg  0.65          0.60      0.60           10
AUC-ROC:  0.625
LOGLOSS Value is 13.815750437193334

Performance Metrics for Regression Problems

我们已经在前面的章节中讨论了回归及其算法。在这里，我们将讨论可以用来评估回归问题的预测的各种性能指标。

Mean Absolute Error (MAE)

它是回归问题中最简单的误差指标。它基本上是预测值和实际值之间的绝对差的平均值之和。简而言之，有了 MAE，我们就可以了解预测有多错误。MAE 不会指明模型的方向，即不会指明模型的欠佳表现或表现过强。以下是计算 MAE 的公式：

其中，Y = 实际输出值

以及 Y^ = 预测输出值。

我们可以使用 sklearn.metrics 的 mean_absolute_error 函数计算 MAE。

Mean Square Error (MSE)

MSE 类似于 MAE，唯一的区别在于在对所有数据求和之前，它对实际值和预测输出值之差进行求平方，而不是使用绝对值。以下公式显示了差异：

其中，Y = 实际输出值

以及 Y^ = 预测输出值。

我们可以使用 sklearn.metrics 的 mean_squared_error 函数计算 MSE。

R Squared (R2)

R 平方指标通常用于解释目的，并指示一组预测输出值对实际输出值的拟合优度。以下公式将帮助我们理解它：

在以上公式中，分子是 MSE，分母是 Y 值中的方差。

我们可以使用 Sklearn.metrics 的 r2_score 函数来计算 R 平方值。

Example

以下是 Python 中的一个简单代码示例，将让我们了解如何将上述解释的性能指标用于回归模型 -

from sklearn.metrics import r2_score
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
X_actual = [5, -1, 2, 10]
Y_predic = [3.5, -0.9, 2, 9.9]
print ('R Squared =',r2_score(X_actual, Y_predic))
print ('MAE =',mean_absolute_error(X_actual, Y_predic))
print ('MSE =',mean_squared_error(X_actual, Y_predic))

Output

R Squared = 0.9656060606060606
MAE = 0.42499999999999993
MSE = 0.5674999999999999

Machine Learning - Automatic Workflows

Introduction

为了成功执行和生成结果，机器学习模型必须自动化一些标准工作流。自动化这些标准工作流的过程可以在 Scikit-learn Pipelines 的帮助下完成。从数据科学家的角度来看，管道是一个概括的，但非常重要的概念。它基本上允许数据从原始格式流向某些有用信息。管道的工作原理可以用以下图表理解 −

机器学习管道的模块如下 −

Data ingestion − 正如其名称所暗示的，这是为在机器学习项目中使用而导入数据的过程。数据可以从单个或多个系统中实时或批量提取。这是最具挑战性的步骤之一，因为数据质量会影响整个机器学习模型。

Data Preparation − 导入数据后，我们需要准备数据以便用于我们的机器学习模型。数据预处理是最重要的数据准备技术之一。

ML Model Training − 下一步是训练我们的机器学习模型。我们有各种机器学习算法，如监督、无监督、强化，用于从数据中提取特征并进行预测。

Model Evaluation − 其次，我们需要评估机器学习模型。在自动机器学习管道的情况下，机器学习模型可以在各种统计方法和业务规则的帮助下进行评估。

ML Model retraining − 在自动机器学习管道的情况下，第一个模型不一定是最好的。第一个模型被视为基线模型，我们可以重复训练它以提高模型的准确性。

Deployment − 最后，我们需要部署模型。此步骤涉及将模型应用于业务运营并将其迁移到业务运营中供其使用。

Challenges Accompanying ML Pipelines

为了创建机器学习管道，数据科学家面临许多挑战。这些挑战归为以下三类 −

Quality of Data

任何机器学习模型的成功在很大程度上取决于数据的质量。如果我们提供给机器学习模型的数据不准确、不可靠和稳健，那么我们最终会得到错误或误导性的输出。

Data Reliability

与 ML 管道相关的另一个挑战是我们要提供给 ML 模型的数据的可靠性。如我们所知，数据科学家可以从多个来源获取数据，但要获得最佳结果，必须确保数据来源是可靠且受信任的。

Data Accessibility

要从 ML 管道中获得最佳结果，数据本身必须是可访问的，这需要整合、清理和管理数据。由于数据可访问性属性，元数据将用新标签进行更新。

Modelling ML Pipeline and Data Preparation

数据泄露（发生在训练数据集到测试数据集）是数据科学家在为 ML 模型准备数据时要处理的一个重要问题。通常，在数据准备时，数据科学家会在学习前对整个数据集使用标准化或归一化等技术。但这些技术无法帮助我们避免数据泄露，因为训练数据集将受到测试数据集中数据的规模的影响。

通过使用 ML 管道，我们可以防止此数据泄露，因为管道确保数据准备（例如此处标准化）受到我们的交叉验证过程的每个折的影响。

Example

以下是一个演示数据准备和模型评估工作流的 Python 示例。为此，我们从 Sklearn 中使用 Pima Indian Diabetes 数据集。首先，我们将创建一个对数据进行标准化的管道。然后将创建线性判别分析模型，最后将使用 10 折交叉验证对管道进行评估。

首先，按如下所示导入所需包：

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

现在，我们需要加载 Pima diabetes 数据集，如在之前的示例中所做的那样：

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values

接下来，我们将借助以下代码创建一个管道：

estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('lda', LinearDiscriminantAnalysis()))
model = Pipeline(estimators)

最后，我们将评估该管道并输出其准确度，如下所示：

kfold = KFold(n_splits=20, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7790148448043184

以上输出是对该设置的准确度的摘要，该设置位于数据集上。

Modelling ML Pipeline and Feature Extraction

数据泄露也可能发生在机器学习模型的特征提取步骤中。这就是为什么也应当限制特征提取程序来阻止训练数据集中发生数据泄露。与数据准备的情况一样，通过使用机器学习管道，我们也可以防止此数据泄露。ML 管道提供的一个名为 FeatureUnion 的工具可用于此目的。

Example

以下是在 Python 中演示特征提取和模型评估工作流的一个示例。为此，我们正在使用来自 Sklearn 的 Pima 印第安人糖尿病数据集。

首先，将用 PCA（主成分分析）提取 3 个特征。然后，将用统计分析提取 6 个特征。在特征提取之后，将通过使用

FeatureUnion 工具。最后，创建一个逻辑回归模型，使用十倍交叉验证评估管道。

首先，按如下所示导入所需包：

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.pipeline import FeatureUnion
from sklearn.linear_model import LogisticRegression
from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest

现在，我们需要加载 Pima diabetes 数据集，如在之前的示例中所做的那样：

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values

接下来，按如下方式创建特征并集 -

features = []
features.append(('pca', PCA(n_components=3)))
features.append(('select_best', SelectKBest(k=6)))
feature_union = FeatureUnion(features)

接下来，使用以下脚本行创建管道 -

estimators = []
estimators.append(('feature_union', feature_union))
estimators.append(('logistic', LogisticRegression()))
model = Pipeline(estimators)

最后，我们将评估该管道并输出其准确度，如下所示：

kfold = KFold(n_splits=20, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7789811066126855

以上输出是对该设置的准确度的摘要，该设置位于数据集上。

Improving Performance of ML Models

Performance Improvement with Ensembles

集成可以通过组合多个模型为我们提升机器学习结果。基本上，集成模型包含几个单独训练的监督学习模型，将它们的结果通过各种方式合并以实现比单个模型更好的预测性能。集成方法可以分成以下两组 −

Sequential ensemble methods

顾名思义，在这些种类的集成方法中，基础学习器会被顺序生成。此类方法的动机是利用基础学习器之间的依赖关系。

Parallel ensemble methods

顾名思义，在这些种类的集成方法中，基础学习器会被并行生成。此类方法的动机是利用基础学习器之间的独立性。

Ensemble Learning Methods

以下是最流行的集成学习方法，即组合不同模型的预测的方法 −

Bagging

装袋法也称为引导聚合。在装袋方法中，集成模型尝试通过结合单个模型的预测（这些模型是根据随机生成的训练样本进行训练的）来提高预测精度并降低模型方差。集成模型的最终预测将通过计算所有预测的平均值来给出。装袋方法的最佳示例之一是随机森林。

Boosting

在推进方法中，构建集成模型的主要原则是通过顺序训练每个基础模型估计量来逐步构建集成模型。顾名思义，它基本上结合多个较弱的基础学习器（在训练数据的多次迭代中顺序训练），构建强大的集成模型。在较弱的基础学习器的训练期间，将为较早被错误分类的学习器分配更大的权重。推进方法的一个示例是 AdaBoost。

Voting

在此集成学习模型中，将构建多种不同类型的模型，并且一些简单的统计信息（例如计算均值或中位数等）用于组合预测。此预测将用作训练的附加输入以做出最终预测。

Bagging Ensemble Algorithms

以下三个是装袋集成算法 −

Bagged Decision Tree

众所周知，装袋集成法适用于方差较高的算法，在这一方面，决策树算法属于佼佼者。在以下 Python 配方中，我们将使用 sklearn 的 BaggingClassifier 函数和 DecisionTreeClassifier（一种分类和回归树算法）在 Pima Indians 糖尿病数据集上建立装袋决策树集成模型。

首先，按如下所示导入所需包：

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

现在，我们需要加载 Pima 糖尿病数据集，如我们在前面的示例中所做的那样 −

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

接下来，输入 10 倍交叉验证，如下所示 −

seed = 7
kfold = KFold(n_splits=10, random_state=seed)
cart = DecisionTreeClassifier()

我们需要提供要构建的树的数量。这里我们构建 150 棵树 −

num_trees = 150

接下来，借助以下脚本构建模型 −

model = BaggingClassifier(base_estimator=cart, n_estimators=num_trees, random_state=seed)

计算并打印结果，如下所示 −

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7733766233766234

上面显示的输出表明，我们的袋装决策树分类器模型的准确率约为 77%。

Random Forest

它是装袋决策树的延伸。对于单独的分类器，训练数据集的样本是替换抽取的，但树是以这样的方式构建的，从而降低它们之间的相关性。另外，在构建每棵树时，会考虑特征的随机子集来选择每个分割点，而不是贪心地选择最佳分割点。

在以下 Python 配方中，我们将使用 sklearn 的 RandomForestClassifier 类在 Pima Indians 糖尿病数据集上建立装袋随机森林集成模型。

首先，按如下所示导入所需包：

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier

现在，我们需要加载 Pima diabetes 数据集，如在之前的示例中所做的那样：

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

接下来，输入 10 倍交叉验证，如下所示 −

seed = 7
kfold = KFold(n_splits=10, random_state=seed)

我们需要提供要构建的树的数量。这里我们将构建 150 棵树，分割点从 5 个特征中选取 −

num_trees = 150
max_features = 5

接下来，借助以下脚本构建模型 −

model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)

计算并打印结果，如下所示 −

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7629357484620642

上面显示的输出表明，我们的装袋随机森林分类器模型的准确率约为 76%。

Extra Trees

它是装袋决策树集成法的另一个延伸。在这种方法中，随机树是从训练数据集的样本构建的。

在以下 Python 配方中，我们将使用 sklearn 的 ExtraTreesClassifier 类在 Pima Indians 糖尿病数据集上构建额外树集成模型。

首先，按如下所示导入所需包：

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import ExtraTreesClassifier

现在，我们需要加载 Pima diabetes 数据集，如在之前的示例中所做的那样：

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

接下来，输入 10 倍交叉验证，如下所示 −

seed = 7
kfold = KFold(n_splits=10, random_state=seed)

我们需要提供要构建的树的数量。这里我们将构建 150 棵树，分割点从 5 个特征中选取 −

num_trees = 150
max_features = 5

接下来，借助以下脚本构建模型 −

model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)

计算并打印结果，如下所示 −

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7551435406698566

上面显示的输出表明，我们的装袋额外树分类器模型的准确率约为 75.5%。

Boosting Ensemble Algorithms

以下是两种最常见的提升集成算法 −

AdaBoost

它是其中一个最成功的提升集成算法。此算法的主要关键在于赋予数据集中的实例的权重方式。因此，该算法在构建后续模型时需要较少地关注这些实例。

在以下 Python 配方中，我们将使用 sklearn 的 AdaBoostClassifier 类在 Pima Indians 糖尿病数据集上构建 Ada Boost 集成模型，用于分类。

首先，按如下所示导入所需包：

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import AdaBoostClassifier

现在，我们需要加载 Pima diabetes 数据集，如在之前的示例中所做的那样：

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

接下来，输入 10 倍交叉验证，如下所示 −

seed = 5
kfold = KFold(n_splits=10, random_state=seed)

我们需要提供要构建的树的数量。这里我们将构建 150 棵树，分割点从 5 个特征中选取 −

num_trees = 50

接下来，借助以下脚本构建模型 −

model = AdaBoostClassifier(n_estimators=num_trees, random_state=seed)

计算并打印结果，如下所示 −

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7539473684210527

上面显示的输出表明，我们的 AdaBoost 分类器集成模型的准确率约为 75%。

Stochastic Gradient Boosting

它也被称为梯度提升机。在以下 Python 配方中，我们将使用 sklearn 的 GradientBoostingClassifier 类在 Pima Indians 糖尿病数据集上构建随机梯度提升集成模型，用于分类。

首先，按如下所示导入所需包：

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingClassifier

现在，我们需要加载 Pima diabetes 数据集，如在之前的示例中所做的那样：

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

接下来，输入 10 倍交叉验证，如下所示 −

seed = 5
kfold = KFold(n_splits=10, random_state=seed)

我们需要提供要构建的树的数量。这里我们将构建 150 棵树，分割点从 5 个特征中选取 −

num_trees = 50

接下来，借助以下脚本构建模型 −

model = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)

计算并打印结果，如下所示 −

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Output

0.7746582365003418

上面的输出表明，我们的梯度提升分类器集成模型准确率约为 77.5%。

Voting Ensemble Algorithms

如讨论所述，投票首先从训练数据集创建两个或更多独立的模型，然后投票分类器将围绕模型进行封装，同时根据需要对子模型的预测结果求取平均值以生成新数据。

在以下 Python 配方中，我们将使用 sklearn 中的 VotingClassifier 类对 Pima Indian 糖尿病数据集建立投票集成模型，用于分类。我们对逻辑回归、决策树分类器和 SVM 的预测结果进行组合，如下所示，用于解决分类问题 −

首先，按如下所示导入所需包：

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier

现在，我们需要加载 Pima diabetes 数据集，如在之前的示例中所做的那样：

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

接下来，输入 10 倍交叉验证，如下所示 −

kfold = KFold(n_splits=10, random_state=7)

接下来，我们需要创建子模型，如下所示 −

estimators = []
model1 = LogisticRegression()
estimators.append(('logistic', model1))
model2 = DecisionTreeClassifier()
estimators.append(('cart', model2))
model3 = SVC()
estimators.append(('svm', model3))

现在，通过组合上述创建的子模型的预测结果来创建投票集成模型。

ensemble = VotingClassifier(estimators)
results = cross_val_score(ensemble, X, Y, cv=kfold)
print(results.mean())

Output

0.7382262474367738

上面的输出表明，我们的投票分类器集成模型的准确率约为 74%。

Improving Performance of ML Model (Contd…)

Performance Improvement with Algorithm Tuning

众所周知，ML 模型以这样一种方式进行参数化，即可以调整它们的行为以解决特定问题。算法调优是指找到这些参数的最佳组合，以便提高 ML 模型的性能。此过程有时称为超参数优化，算法本身的参数称为超参数，ML 算法找到的系数称为参数。

在此，我们将讨论 Python Scikit-learn 提供的算法参数调优的一些方法。

Grid Search Parameter Tuning

这是一种参数调优方法。此方法的工作要点是，针对网格中指定的每个可能的算法参数组合有条不紊地构建和评估模型方法。因此，我们可以说此算法具有搜索性质。

Example

在以下 Python 代码示例中，我们将使用 Sklearn 的 GridSearchCV 类对 Pima 印第安人糖尿病数据集执行网格搜索，以评估岭回归算法的各个 alpha 值。

首先，按如下所示导入所需包：

import numpy
from pandas import read_csv
from sklearn.linear_model import Ridge
from sklearn.model_selection import GridSearchCV

现在，我们需要加载 Pima diabetes 数据集，如在之前的示例中所做的那样：

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

接下来，按如下方式评估各个 alpha 值 -

alphas = numpy.array([1,0.1,0.01,0.001,0.0001,0])
param_grid = dict(alpha=alphas)

现在，我们需要对我们的模型应用网格搜索 -

model = Ridge()
grid = GridSearchCV(estimator=model, param_grid=param_grid)
grid.fit(X, Y)

使用以下脚本行打印结果 -

print(grid.best_score_)
print(grid.best_estimator_.alpha)

Output

0.2796175593129722
1.0

以上输出为我们提供了最佳分数以及达到该分数的网格中的参数集。此例中的 alpha 值为 1.0。

Random Search Parameter Tuning

这是一种参数调优方法。此方法的工作要点是，针对固定次数的迭代从随机分布中对算法参数进行采样。

Example

在以下 Python 代码示例中，我们将使用 Sklearn 的 RandomizedSearchCV 类对 Pima 印第安人糖尿病数据集执行随机搜索，以评估岭回归算法的 0 到 1 之间的不同 alpha 值。

首先，按如下所示导入所需包：

import numpy
from pandas import read_csv
from scipy.stats import uniform
from sklearn.linear_model import Ridge
from sklearn.model_selection import RandomizedSearchCV

现在，我们需要加载 Pima diabetes 数据集，如在之前的示例中所做的那样：

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

接下来，按如下方式在岭回归算法上评估各个 alpha 值 -

param_grid = {'alpha': uniform()}
model = Ridge()
random_search = RandomizedSearchCV(estimator=model, param_distributions=param_grid, n_iter=50,
random_state=7)
random_search.fit(X, Y)

使用以下脚本行打印结果 -

print(random_search.best_score_)
print(random_search.best_estimator_.alpha)

Output

0.27961712703051084
0.9779895119966027
0.9779895119966027

以上输出为我们提供了与网格搜索非常相似的最佳分数。