• 人工智能与 Python – 入门概念

• 人工智能与 Python——入门

• 人工智能与 Python——机器学习

• 人工智能与 Python – 数据准备

• 监督学习：分类

• 监督学习：回归

• 人工智能与 Python – 逻辑编程

• 无监督学习：聚类

• 自然语言处理

• 人工智能与 Python——NLTK 包

• 分析时间序列数据

• 人工智能与 Python——语音识别

• 人工智能与 Python——启发式搜索

• 人工智能与 Python – 游戏

• 人工智能与 Python——神经网络

• 强化学习

• 人工智能与 Python——遗传算法

• 人工智能与 Python——计算机视觉

• 人工智能与 Python——深度学习

人工智能与 Python – 入门概念

自计算机或机器发明以来，它们执行各种任务的能力经历了指数级增长。人类在不同的工作领域、不断提高的速度和相对于时间的缩小尺寸方面开发了计算机系统的功能。

名为人工智能的计算机科学的一个分支追求创造像人类一样智能的计算机或机器。

人工智能（AI）的基本概念

按照人工智能之父约翰麦卡锡的说法，它是“制造智能机器，尤其是智能计算机程序的科学与工程”。

人工智能是一种让计算机、计算机控制的机器人或软件以智能人类思考的方式进行智能思考的方法。人工智能是通过研究人脑如何思考以及人类在尝试解决问题时如何学习、决策和工作，然后将这项研究的结果作为开发智能软件和系统的基础来实现的。

在利用计算机系统的力量时，人类的好奇心使他想知道，“机器能像人类一样思考和行动吗？”

因此，人工智能的发展始于在机器中创造我们发现并认为人类具有很高智能的类似智能。

学习人工智能的必要性

众所周知，人工智能追求的是创造像人类一样智能的机器。我们研究人工智能的原因有很多。原因如下 -

人工智能可以通过数据学习

在我们的日常生活中，我们处理大量数据，而人脑无法跟踪这么多数据。这就是为什么我们需要自动化的原因。做自动化，我们需要研究人工智能，因为它可以从数据中学习，可以准确无误地完成重复性的工作，而且不会感到疲倦。

人工智能可以自学

系统自学是非常必要的，因为数据本身不断变化，从这些数据中衍生出来的知识也必须不断更新。我们可以使用 AI 来实现这一目的，因为支持 AI 的系统可以自学。

AI可以实时响应

借助神经网络的人工智能可以更深入地分析数据。由于这种能力，人工智能可以实时思考和响应基于条件的情况。

人工智能实现准确性

在深度神经网络的帮助下，人工智能可以达到极高的准确性。人工智能在医学领域有助于通过患者的 MRI 诊断癌症等疾病。

人工智能可以组织数据以充分利用它

数据是使用自学习算法的系统的知识产权。我们需要 AI 以始终提供最佳结果的方式对数据进行索引和组织。

了解情报

有了人工智能，就可以构建智能系统。我们需要理解智能的概念，这样我们的大脑才能构建另一个像它自己一样的智能系统。

什么是情报？

系统计算、推理、感知关系和类比、从经验中学习、从记忆中存储和检索信息、解决问题、理解复杂思想、流利地使用自然语言、分类、概括和适应新情况的能力。

智力类型

正如美国发展心理学家霍华德加德纳所描述的那样，智力来自多方面 -

高级编号情报与描述例子1个

语言智能

说话、识别和使用音系（语音）、句法（语法）和语义（意义）机制的能力。

叙述者、演说者2个

音乐智能

创造、交流和理解声音意义的能力，对音调和节奏的理解。

音乐家、歌手、作曲家3个

逻辑数理智能

在没有动作或对象的情况下使用和理解关系的能力。这也是理解复杂和抽象思想的能力。

数学家、科学家4个

空间智能

感知视觉或空间信息，改变它，并在不参考对象的情况下重新创建视觉图像，构建 3D 图像以及移动和旋转它们的能力。

地图阅读器、宇航员、物理学家5个

身体运动智能

能够使用完整或部分身体来解决问题或时尚产品，控制精细和粗略的运动技能，以及操纵物体。

球员、舞者6个

个人内部智能

区分自己的感受、意图和动机的能力。

释迦牟尼佛7

人际智能

识别和区分他人的感受、信念和意图的能力。

大众传播者、采访者

当一台机器或系统配备了至少一种或所有智能时，你可以说它是人工智能。

什么是情报？

智慧是无形的。它由 -

• 推理

• 学习

• 解决问题

• 洞察力

• 语言智能

让我们简要介绍一下所有组件 -

推理

它是使我们能够为判断、决策和预测提供基础的一组过程。大致有两种类型 -

归纳推理演绎推理它进行具体观察以做出广泛的一般性陈述。它从一般性陈述开始，并检查得出特定、合乎逻辑的结论的可能性。即使陈述中的所有前提都为真，归纳推理也允许结论为假。如果某件事对一类事物普遍适用，那么它也适用于该类的所有成员。示例- “Nita 是一位老师。Nita 很勤奋。因此，所有老师都很勤奋。”示例- “所有 60 岁以上的女性都是祖母。Shalini 是 65 岁。因此，Shalini 是祖母。”

学习 - l

人类、特定种类的动物和支持 AI 的系统都具有学习能力。学习分类如下 -

听觉学习

它是通过听和听来学习的。例如，学生收听录制的音频讲座。

情景学习

通过记住亲眼目睹或经历过的一系列事件来学习。这是线性和有序的。

运动学习

它是通过肌肉的精确运动来学习的。比如捡东西，写字等等。

观察学习

通过观察和模仿他人来学习。例如，孩子试图通过模仿父母来学习。

感性学习

它正在学习识别以前见过的刺激。例如，识别和分类对象和情况。

关系学习

它涉及学习根据相关属性而不是绝对属性来区分各种刺激。例如，在烹饪上次变咸的土豆时添加“少一点”盐，当烹饪时添加一汤匙盐。

• 空间学习- 它是通过图像、颜色、地图等视觉刺激进行学习。例如，一个人可以在真正沿着道路行驶之前在脑海中创建路线图。

• Stimulus-Response Learning - 它正在学习在存在特定刺激时执行特定行为。例如，一只狗在听到门铃时会竖起耳朵。

解决问题

这是一个过程，在这个过程中，一个人通过采取一些被已知或未知障碍阻挡的路径来感知并试图从当前情况中得出所需的解决方案。

解决问题还包括决策，这是从多个备选方案中选择最合适的备选方案以达到预期目标的过程。

洞察力

它是获取、解释、选择和组织感官信息的过程。

感知假定感知。在人类中，感觉器官有助于感知。在人工智能领域，感知机制将传感器获取的数据以有意义的方式组合在一起。

语言智能

它是一个人使用、理解、说和写口头和书面语言的能力。在人际交往中很重要。

人工智能涉及什么

人工智能是一个广阔的研究领域。该研究领域有助于找到解决现实世界问题的方法。

现在让我们看看人工智能的不同研究领域 -

机器学习

它是人工智能最受欢迎的领域之一。本申请的基本概念是让机器从数据中学习，就像人类可以从他/她的经验中学习一样。它包含学习模型，在此基础上可以对未知数据进行预测。

逻辑

这是另一个重要的研究领域，其中使用数理逻辑来执行计算机程序。它包含执行模式匹配、语义分析等的规则和事实。

搜索中

这一研究领域基本上用于象棋、井字游戏等游戏。搜索算法在搜索整个搜索空间后给出最优解。

人工神经网络

这是一个高效计算系统网络，其中心主题借鉴了生物神经网络的类比。人工神经网络可用于机器人、语音识别、语音处理等。

遗传算法

遗传算法有助于在多个程序的帮助下解决问题。结果将基于选择最适者。

知识表示

在研究领域的帮助下，我们可以用机器可以理解的方式来表示事实。知识的表达效率越高；系统越智能。

人工智能的应用

在本节中，我们将看到 AI 支持的不同领域 -

赌博

人工智能在国际象棋、扑克、井字游戏等战略游戏中起着至关重要的作用，机器可以根据启发式知识思考大量可能的位置。

自然语言处理

可以与理解人类所说的自然语言的计算机进行交互。

专家系统

有些应用程序集成了机器、软件和特殊信息以提供推理和建议。他们向用户提供解释和建议。

视觉系统

这些系统理解、解释和理解计算机上的视觉输入。例如，

• 间谍飞机拍摄照片，这些照片用于计算空间信息或区域地图。

• 医生使用临床专家系统对患者进行诊断。

• 警察使用计算机软件，可以通过法医艺术家制作的存储肖像识别罪犯的面孔。

语音识别

一些智能系统能够在人类与之交谈时根据句子及其含义来听取和理解语言。它可以处理不同的口音、俚语、背景噪音、因寒冷引起的人声变化等。

手写识别

手写识别软件读取用笔写在纸上或用手写笔写在屏幕上的文本。它可以识别字母的形状并将其转换为可编辑的文本。

智能机器人

机器人能够执行人类赋予的任务。他们有传感器来检测来自现实世界的物理数据，例如光、热、温度、运动、声音、碰撞和压力。它们拥有高效的处理器、多个传感器和巨大的内存，以展现智能。此外，他们能够从错误中吸取教训，能够适应新环境。

认知建模：模拟人类思维过程

认知建模基本上是计算机科学中的研究领域，涉及研究和模拟人类的思维过程。人工智能的主要任务是让机器像人一样思考。人类思维过程的最重要特征是解决问题。这就是为什么或多或少的认知建模试图理解人类如何解决问题的原因。之后，该模型可用于各种人工智能应用，如机器学习、机器人技术、自然语言处理等。以下是人脑不同思维层次的图表 -

代理与环境

在本节中，我们将重点关注代理和环境以及它们如何帮助人工智能。

代理人

代理是任何可以通过传感器感知其环境并通过效应器作用于该环境的事物。

• 人类主体具有与传感器平行的眼睛、耳朵、鼻子、舌头和皮肤等感觉器官，以及用于效应器的其他器官，例如手、腿、嘴。

• 机器人代理取代了传感器的相机和红外测距仪，以及效应器的各种电机和执行器。

• 软件代理将位串编码为它的程序和动作。

环境

一些程序在完全人工的环境中运行，仅限于键盘输入、数据库、计算机文件系统和屏幕上的字符输出。

相比之下，一些软件代理（软件机器人或软件机器人）存在于丰富的、无限的软件机器人域中。模拟器有一个非常详细、复杂的环境。软件代理需要从一长串实时操作中进行选择。softbot 旨在扫描客户的在线偏好，并向客户展示有趣的项目，在真实和人工环境中工作。

人工智能与 Python——入门

在本章中，我们将学习如何开始使用 Python。我们还将了解 Python 如何帮助人工智能。

为什么 Python 用于 AI

人工智能被认为是未来的趋势技术。已经有许多应用程序在上面进行。因此，许多公司和研究人员都对此感兴趣。但这里出现的主要问题是，可以使用哪种编程语言开发这些 AI 应用程序？有多种编程语言，如 Lisp、Prolog、C++、Java 和 Python，可用于开发 AI 应用程序。其中，Python 编程语言大受欢迎，原因如下：

简单的语法和更少的编码

与其他可用于开发 AI 应用程序的编程语言相比，Python 涉及的代码非常少，语法简单。由于这个特性，测试可以更容易，我们可以更专注于编程。

人工智能项目的内置库

将 Python 用于 AI 的一个主要优势是它带有内置库。Python 拥有适用于几乎所有类型 AI 项目的库。例如，NumPy、SciPy、matplotlib、nltk、SimpleAI是 Python 的一些重要内置库。

• 开源- Python 是一种开源编程语言。这使其在社区中广受欢迎。

• 可用于广泛的编程——Python 可用于广泛的编程任务，如小型 shell 脚本到企业 Web 应用程序。这也是 Python 适合 AI 项目的另一个原因。

Python的特点

Python 是一种高级、解释型、交互式和面向对象的脚本语言。Python 被设计成具有高度可读性。它经常使用英语关键字，而其他语言使用标点符号，并且它的句法结构比其他语言少。Python 的功能包括以下 -

• Easy-to-learn - Python 关键字少，结构简单，语法定义明确。这使学生能够快速掌握语言。

• Easy-to-read - Python 代码定义更清晰，更清晰可见。

• Easy-to-maintain - Python 的源代码相当易于维护。

• 广泛的标准库——Python 的大部分库在 UNIX、Windows 和 Macintosh 上都非常便携且跨平台兼容。

• 交互模式- Python 支持交互模式，允许交互测试和调试代码片段。

• 便携- Python 可以在多种硬件平台上运行，并且在所有平台上都具有相同的界面。

• 可扩展- 我们可以向 Python 解释器添加低级模块。这些模块使程序员能够添加或自定义他们的工具以提高效率。

• 数据库- Python 提供所有主要商业数据库的接口。

• GUI 编程- Python 支持可以创建和移植到许多系统调用、库和 Windows 系统（例如 Windows MFC、Macintosh 和 Unix 的 X Window 系统）的 GUI 应用程序。

• 可扩展- Python 为大型程序提供了比 shell 脚本更好的结构和支持。

Python的重要特性

现在让我们考虑 Python 的以下重要特性 -

• 它支持函数式和结构化编程方法以及 OOP。

• 它可以用作脚本语言，也可以编译为字节码以构建大型应用程序。

• 它提供非常高级的动态数据类型并支持动态类型检查。

• 它支持自动垃圾收集。

• 它可以轻松地与 C、C++、COM、ActiveX、CORBA 和 Java 集成。

安装 Python

Python 发行版可用于大量平台。您只需下载适用于您的平台的二进制代码并安装 Python。

如果您的平台的二进制代码不可用，您需要一个 C 编译器来手动编译源代码。编译源代码在选择安装中所需的功能方面提供了更大的灵活性。

这是在各种平台上安装 Python 的快速概述 -

Unix 和 Linux 安装

按照以下步骤在 Unix/Linux 机器上安装 Python。

• 打开 Web 浏览器并转到https://www.python.org/downloads

• 按照链接下载适用于 Unix/Linux 的压缩源代码。

• 下载并提取文件。

• 如果要自定义某些选项，请编辑模块/设置文件。

• 运行 ./configure 脚本

• 制作

• 安装

这会将 Python 安装在标准位置 /usr/local/bin，并将其库安装在/usr/local/lib/pythonXX，其中 XX 是 Python 的版本。

Windows 安装

按照以下步骤在 Windows 机器上安装 Python。

• 打开 Web 浏览器并转到https://www.python.org/downloads

• 点击 Windows 安装程序python-XYZ .msi 文件的链接，其中 XYZ 是您需要安装的版本。

• 要使用此安装程序python-XYZ .msi，Windows 系统必须支持 Microsoft Installer 2.0。将安装程序文件保存到您的本地计算机，然后运行它以查看您的计算机是否支持 MSI。

• 运行下载的文件。这将打开 Python 安装向导，它非常易于使用。只需接受默认设置并等待安装完成即可。

苹果机安装

如果您使用的是 Mac OS X，建议您使用 Homebrew 安装 Python 3。它是一个很棒的 Mac OS X 软件包安装程序，而且非常易于使用。如果您没有 Homebrew，您可以使用以下命令安装它 -

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

我们可以使用以下命令更新包管理器 -

$ brew update

现在运行以下命令在您的系统上安装 Python3 -

$ brew install python3

设置路径

程序和其他可执行文件可以位于许多目录中，因此操作系统提供了一个搜索路径，其中列出了操作系统搜索可执行文件的目录。

路径存储在环境变量中，这是操作系统维护的命名字符串。此变量包含可用于命令 shell 和其他程序的信息。

路径变量在 Unix 中命名为 PATH，在 Windows 中命名为 Path（Unix 区分大小写；Windows 不区分大小写）。

在 Mac OS 中，安装程序会处理路径详细信息。要从任何特定目录调用 Python 解释器，您必须将 Python 目录添加到您的路径中。

在 Unix/Linux 下设置路径

将 Python 目录添加到 Unix 中特定会话的路径 -

• 在 csh 外壳中

  输入setenv PATH "$PATH:/usr/local/bin/python"并按Enter。

• 在 bash shell (Linux) 中

  键入export ATH = "$PATH:/usr/local/bin/python"并按Enter。

• 在 sh 或 ksh shell 中

  键入PATH = "$PATH:/usr/local/bin/python"并按Enter。

注意- /usr/local/bin/python 是 Python 目录的路径。

在 Windows 中设置路径

将 Python 目录添加到 Windows 中特定会话的路径 -

• 在命令提示符下- 键入path %path%;C:Python并按Enter键。

注意- C:Python 是 Python 目录的路径。

运行 Python

现在让我们看看运行 Python 的不同方式。这些方法如下所述 -

交互式口译员

我们可以从 Unix、DOS 或任何其他为您提供命令行解释器或 shell 窗口的系统启动 Python。

• 在命令行输入python 。

• 立即在交互式解释器中开始编码。

$python # Unix/Linux

或者

python% # Unix/Linux

或者

C:> python # Windows/DOS

以下是所有可用命令行选项的列表 -

编号选项和描述1个

-d

它提供调试输出。

2个

-o

它生成优化的字节码（生成 .pyo 文件）。

3个

-S

不要在启动时运行 import site 来查找 Python 路径。

4个

-v

详细输出（导入语句的详细跟踪）。

5个

-X

禁用基于类的内置异常（仅使用字符串）；从 1.6 版开始已过时。

6个

-c命令

运行作为 cmd 字符串发送的 Python 脚本。

7

文件

从给定文件运行 Python 脚本。

来自命令行的脚本

可以通过在应用程序上调用解释器在命令行执行 Python 脚本，如下所示 -

$python script.py # Unix/Linux

或者，

python% script.py # Unix/Linux

或者，

C:> python script.py # Windows/DOS

注意- 确保文件权限模式允许执行。

集成开发环境

如果您的系统上有支持 Python 的 GUI 应用程序，您也可以从图形用户界面 (GUI) 环境运行 Python。

• Unix - IDLE 是第一个用于 Python 的 Unix IDE。

• Windows - PythonWin 是 Python 的第一个 Windows 界面，是一个带有 GUI 的 IDE。

• Macintosh - Macintosh 版本的 Python 以及 IDLE IDE 可从主网站获得，可下载为 MacBinary 或 BinHex'd 文件。

如果您无法正确设置环境，则可以向系统管理员寻求帮助。确保 Python 环境设置正确并且运行良好。

我们还可以使用另一个名为 Anaconda 的 Python 平台。它包括数百个流行的数据科学包和适用于 Windows、Linux 和 MacOS 的 conda 包和虚拟环境管理器。您可以根据您的操作系统从链接https://www.anaconda.com/download/下载它。

对于本教程，我们在 MS Windows 上使用 Python 3.6.3 版本。

人工智能与 Python——机器学习

学习是指通过学习或经验获得知识或技能。基于此，我们可以定义机器学习（ML）如下 -

它可以定义为计算机科学领域，更具体地说是人工智能的应用，它为计算机系统提供了利用数据进行学习并根据经验进行改进的能力，而无需明确编程。

基本上，机器学习的主要重点是让计算机在没有人为干预的情况下自动学习。现在的问题是，如何开始和完成这样的学习？它可以从数据观察开始。数据也可以是一些示例、说明或一些直接经验。然后在这个输入的基础上，机器通过寻找数据中的一些模式来做出更好的决策。

机器学习 (ML) 的类型

机器学习算法帮助计算机系统在没有明确编程的情况下进行学习。这些算法分为有监督的或无监督的。现在让我们看看一些算法 -

监督机器学习算法

这是最常用的机器学习算法。之所以称为有监督的，是因为从训练数据集学习算法的过程可以被认为是老师监督学习过程。在这种 ML 算法中，可能的结果是已知的，训练数据也标有正确答案。可以理解如下 -

假设我们有输入变量x和输出变量y，我们应用了一种算法来学习从输入到输出的映射函数，例如 -

Y = f(x)

现在，主要目标是很好地近似映射函数，以便当我们有新的输入数据 (x) 时，我们可以预测该数据的输出变量 (Y)。

主要有监督的学习问题可以分为以下两种问题 -

• 分类- 当我们有分类输出如“黑色”，“教学”，“非教学”等时，一个问题称为分类问题。

• 回归- 当我们有诸如“距离”、“千克”等真实值输出时，一个问题称为回归问题。

决策树、随机森林、knn、逻辑回归是监督机器学习算法的例子。

无监督机器学习算法

顾名思义，这类机器学习算法没有任何主管提供任何指导。这就是为什么无监督机器学习算法与某些人所谓的真正人工智能密切相关的原因。可以理解如下 -

假设我们有输入变量 x，那么就没有监督学习算法中相应的输出变量。

简单来说，我们可以说，在无监督学习中，没有正确答案，也没有老师指导。算法有助于发现数据中有趣的模式。

无监督学习问题可分为以下两种问题 -

• 聚类- 在聚类问题中，我们需要发现数据中的固有分组。例如，按购买行为对客户进行分组。

• Association - 一个问题被称为关联问题，因为这类问题需要发现描述我们大部分数据的规则。例如，查找同时购买x和y的客户。

用于聚类的 K-means、用于关联的 Apriori 算法是无监督机器学习算法的示例。

强化机器学习算法

这类机器学习算法用得很少。这些算法训练系统做出特定的决定。基本上，机器暴露在一个环境中，在这个环境中，它使用试错法不断地自我训练。这些算法从过去的经验中学习，并试图捕捉最好的知识来做出准确的决策。马尔可夫决策过程是强化机器学习算法的一个例子。

最常见的机器学习算法

在本节中，我们将了解最常见的机器学习算法。算法描述如下 -

线性回归

它是统计和机器学习中最著名的算法之一。

基本概念 - 主要是线性回归是一种线性模型，它假设输入变量 x 和单个输出变量 y 之间存在线性关系。换句话说，我们可以说 y 可以从输入变量 x 的线性组合中计算出来。可以通过拟合最佳线来建立变量之间的关系。

线性回归的类型

线性回归有以下两种类型 -

• 简单线性回归- 如果线性回归算法只有一个自变量，则称为简单线性回归。

• 多元线性回归- 如果线性回归算法具有多个自变量，则称为多元线性回归。

线性回归主要用于根据连续变量估计实际值。例如，可以通过线性回归估算基于实际值的商店一天的总销售额。

逻辑回归

它是一种分类算法，也称为逻辑回归。

主要是逻辑回归是一种分类算法，用于根据给定的自变量集估计离散值，如 0 或 1、真或假、是或否。基本上，它预测概率，因此其输出介于 0 和 1 之间。

决策树

决策树是一种监督学习算法，主要用于分类问题。

基本上它是一个分类器，表示为基于自变量的递归分区。决策树具有形成有根树的节点。有根树是有向树，其节点称为“根”。Root 没有任何入边，所有其他节点都有一个入边。这些节点称为叶节点或决策节点。例如，考虑以下决策树来查看一个人是否适合。

支持向量机 (SVM)

它用于分类和回归问题。但主要用于分类问题。SVM 的主要概念是将每个数据项绘制为 n 维空间中的一个点，每个特征的值是特定坐标的值。这里 n 是我们将拥有的特征。以下是理解 SVM 概念的简单图形表示 -

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

朴素贝叶斯

这也是一种分类技术。这种分类技术背后的逻辑是使用贝叶斯定理来构建分类器。假设预测变量是独立的。简而言之，它假设类中特定特征的存在与任何其他特征的存在无关。以下是贝叶斯定理的等式 -

$$Pleft ( rac{A}{B} ight ) = rac{Pleft ( rac{B}{A} ight )Pleft ( A ight )}{Pleft ( B 右 )}$$

朴素贝叶斯模型易于构建，对大型数据集特别有用。

K 最近邻 (KNN)

它用于问题的分类和回归。它被广泛用于解决分类问题。该算法的主要概念是它用于存储所有可用的案例，并根据其 k 个邻居的多数票对新案例进行分类。然后将案例分配给在其 K 近邻中最常见的类，通过距离函数测量。距离函数可以是欧氏距离、闵可夫斯基距离和汉明距离。考虑以下使用 KNN -

• 在计算上，KNN 比用于分类问题的其他算法昂贵。

• 需要对变量进行归一化，否则更高范围的变量会使它产生偏差。

• 在 KNN 中，我们需要在去噪等预处理阶段进行工作。

K-均值聚类

顾名思义，就是用来解决聚类问题的。它基本上是一种无监督学习。K-Means 聚类算法的主要逻辑是通过多个簇对数据集进行分类。按照以下步骤通过 K-means 形成集群 -

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

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

• 现在，它将根据现有的集群成员找到每个集群的质心。

• 我们需要重复这些步骤，直到出现收敛。

随机森林

它是一种监督分类算法。随机森林算法的优点是它可以用于分类和回归类问题。基本上它是决策树（即森林）的集合，或者你可以说是决策树的集合。随机森林的基本概念是每棵树给出一个分类，森林从中选择最好的分类。以下是随机森林算法的优点 -

• 随机森林分类器可用于分类和回归任务。

• 他们可以处理缺失值。

• 即使我们在森林中有更多的树木，它也不会过度拟合模型。

人工智能与 Python – 数据准备

我们已经研究了有监督和无监督的机器学习算法。这些算法需要格式化数据才能开始训练过程。我们必须以某种方式准备或格式化数据，以便它可以作为 ML 算法的输入提供。

本章重点介绍机器学习算法的数据准备。

预处理数据

在我们的日常生活中，我们处理大量数据，但这些数据都是原始形式。为了提供数据作为机器学习算法的输入，我们需要将其转换为有意义的数据。这就是数据预处理的用武之地。换句话说，我们可以说，在将数据提供给机器学习算法之前，我们需要对数据进行预处理。

数据预处理步骤

按照以下步骤在 Python 中预处理数据 -

第 1 步 - 导入有用的包- 如果我们使用 Python，那么这将是将数据转换为特定格式的第一步，即预处理。可以按如下方式完成 -

import numpy as np
import sklearn.preprocessing

在这里，我们使用了以下两个包 -

• NumPy - 基本上，NumPy 是一个通用的数组处理包，旨在有效地操作任意记录的大型多维数组，而不会为小型多维数组牺牲太多速度。

• Sklearn.preprocessing - 该包提供了许多常用的实用函数和转换器类，用于将原始特征向量更改为更适合机器学习算法的表示。

第 2 步 - 定义样本数据- 导入包后，我们需要定义一些样本数据，以便我们可以对该数据应用预处理技术。我们现在将定义以下示例数据 -

input_data = np.array([2.1, -1.9, 5.5],
                      [-1.5, 2.4, 3.5],
                      [0.5, -7.9, 5.6],
                      [5.9, 2.3, -5.8])

Step3 - Applying preprocessing technique - 在此步骤中，我们需要应用任何预处理技术。

以下部分描述了数据预处理技术。

数据预处理技术

数据预处理技术如下所述 -

二值化

这是我们需要将数值转换为布尔值时使用的预处理技术。我们可以使用内置方法对输入数据进行二值化，例如通过以下方式使用 0.5 作为阈值 -

data_binarized = preprocessing.Binarizer(threshold = 0.5).transform(input_data)print("
Binarized data:
", data_binarized)

现在，运行上面的代码后，我们将得到以下输出，所有高于 0.5（阈值）的值将被转换为 1，所有低于 0.5 的值将被转换为 0。

二值化数据

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

均值去除

这是机器学习中使用的另一种非常常见的预处理技术。基本上它用于从特征向量中消除均值，以便每个特征都以零为中心。我们还可以去除特征向量中特征的偏差。为了对样本数据应用均值去除预处理技术，我们可以编写如下所示的 Python 代码。该代码将显示输入数据的均值和标准差 -

print("Mean = ", input_data.mean(axis = 0))
print("Std deviation = ", input_data.std(axis = 0))

运行以上代码行后，我们将得到以下输出 -

         Mean = [ 1.75       -1.275       2.2]
Std deviation = [ 2.71431391  4.20022321  4.69414529]

现在，下面的代码将删除输入数据的均值和标准差 -

data_scaled = preprocessing.scale(input_data)print("Mean =", data_scaled.mean(axis=0))print("Std deviation =", data_scaled.std(axis = 0))

运行以上代码行后，我们将得到以下输出 -

         Mean = [ 1.11022302e-16 0.00000000e+00 0.00000000e+00]
Std deviation = [ 1.             1.             1.]

缩放

这是另一种用于缩放特征向量的数据预处理技术。需要对特征向量进行缩放，因为每个特征的值都可以在许多随机值之间变化。换句话说，我们可以说缩放很重要，因为我们不希望任何特征综合变大或变小。借助以下 Python 代码，我们可以缩放输入数据，即特征向量 -

# 最小最大缩放

data_scaler_minmax = preprocessing.MinMaxScaler(feature_range=(0,1))data_scaled_minmax = data_scaler_minmax.fit_transform(input_data)print ("
Min max scaled data:
", data_scaled_minmax)

运行以上代码行后，我们将得到以下输出 -

最小最大缩放数据

[ [ 0.48648649  0.58252427   0.99122807][   0.          1.           0.81578947][   0.27027027  0.           1.        ][   1.          0. 99029126  0.        ]]

正常化

这是另一种用于修改特征向量的数据预处理技术。这种修改对于在通用尺度上测量特征向量是必要的。以下是可用于机器学习的两种归一化类型 -

L1归一化

它也被称为最小绝对偏差。这种归一化会修改值，使每行中的绝对值总和始终为 1。它可以在以下 Python 代码的帮助下在输入数据上实现 -

# Normalize data
data_normalized_l1 = preprocessing.normalize(input_data, norm = 'l1')
print("
L1 normalized data:
", data_normalized_l1)

上面的代码行生成以下输出 &miuns;

L1 normalized data:
[[ 0.22105263  -0.2          0.57894737]
[ -0.2027027    0.32432432   0.47297297]
[  0.03571429  -0.56428571   0.4       ]
[  0.42142857   0.16428571  -0.41428571]]

L2 归一化

它也称为最小二乘法。这种归一化会修改值，使每行的平方和始终等于 1。它可以在以下 Python 代码的帮助下在输入数据上实现 -

# Normalize data
data_normalized_l2 = preprocessing.normalize(input_data, norm = 'l2')
print("
L2 normalized data:
", data_normalized_l2)

上面的代码行将生成以下输出 -

L2 normalized data:
[[ 0.33946114  -0.30713151   0.88906489]
[ -0.33325106   0.53320169   0.7775858 ]
[  0.05156558  -0.81473612   0.57753446]
[  0.68706914   0.26784051  -0.6754239 ]]

标记数据

我们已经知道，某种格式的数据对于机器学习算法是必需的。另一个重要要求是，在将数据作为机器学习算法的输入发送之前，必须正确标记数据。例如，如果我们谈论分类，数据上有很多标签。那些标签的形式是文字，数字等。sklearn中机器学习相关的功能要求数据必须有数字标签。因此，如果数据是其他形式，则必须将其转换为数字。这种将单词标签转换为数字形式的过程称为标签编码。

标签编码步骤

按照以下步骤在 Python 中编码数据标签 -

Step1 - 导入有用的包

如果我们使用 Python，那么这将是将数据转换为特定格式的第一步，即预处理。可以按如下方式完成 -

import numpy as npfrom sklearn import preprocessing

第 2 步 - 定义样本标签

导入包后，我们需要定义一些样本标签，以便我们可以创建和训练标签编码器。我们现在将定义以下样本标签 -

# Sample input labelsinput_labels = ['red','black','red','green','black','yellow','white']

第 3 步 - 创建和训练标签编码器对象

在这一步中，我们需要创建标签编码器并对其进行训练。以下 Python 代码将有助于做到这一点 -

# Creating the label encoder
encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)

以下是运行上述 Python 代码后的输出 -

LabelEncoder()

Step4 - 通过编码随机有序列表来检查性能

此步骤可用于通过对随机有序列表进行编码来检查性能。可以编写以下 Python 代码来执行相同的操作 -

# encoding a set of labels
test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("
Labels =", test_labels)

标签将打印如下 -

Labels = ['green', 'red', 'black']

现在，我们可以获得编码值列表，即转换为数字的单词标签如下 -

print("Encoded values =", list(encoded_values))

编码值将打印如下 -

Encoded values = [1, 2, 0]

第 5 步 - 通过解码一组随机数字来检查性能 -

此步骤可用于通过解码随机数字集来检查性能。可以编写以下 Python 代码来执行相同的操作 -

# decoding a set of values
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)
print("
Encoded values =", encoded_values)

现在，编码值将打印如下 -

Encoded values = [3, 0, 4, 1]print("
Decoded labels =", list(decoded_list))

现在，解码值将打印如下 -

Decoded labels = ['white', 'black', 'yellow', 'green']

标记数据与未标记数据

未标记数据主要包括可以从世界上轻松获得的自然或人造物体的样本。它们包括音频、视频、照片、新闻文章等。

另一方面，标记数据采用一组未标记数据，并使用一些有意义的标记或标签或类来扩充每个未标记数据。例如，如果我们有一张照片，那么标签可以根据照片的内容来放置，即它是男孩或女孩或动物或其他任何东西的照片。标记数据需要人类的专业知识或对给定的未标记数据的判断。

在许多情况下，未标记的数据很丰富且易于获取，但标记的数据通常需要人工/专家进行注释。半监督学习试图结合标记和未标记的数据来构建更好的模型。

人工智能与 Python——监督学习：分类

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

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

在 Python 中构建分类器的步骤

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

第 1 步 - 导入 Scikit-learn

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

Import Sklearn

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

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

from sklearn.datasets import load_breast_cancer

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

data = load_breast_cancer()

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

• 分类标签名称(target_names)

• 实际标签（目标）

• 属性/特征名称（feature_names）

• 属性（数据）

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

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

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

print(label_names)

上面的命令将分别打印出恶性和良性的类名。它显示为下面的输出 -

['malignant' 'benign']

现在，下面的命令将显示它们被映射到二进制值 0 和 1。这里 0 代表恶性癌症，1 代表良性癌症。您将收到以下输出 -

print(labels[0])
0

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

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

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

第 3 步 - 将数据组织成集合

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

from sklearn.model_selection import train_test_split

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

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

第 4 步 - 构建模型

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

from sklearn.naive_bayes import GaussianNB

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

gnb = GaussianNB()

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

model = gnb.fit(train, train_labels)

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

在这一步中，我们将通过对测试数据进行预测来评估模型。然后我们也会发现它的准确性。为了进行预测，我们将使用 predict() 函数。以下命令将帮助您执行此操作 -

preds = gnb.predict(test)
print(preds)

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

上面的一系列 0 和 1 是肿瘤类别（恶性和良性）的预测值。

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

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

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

这样，借助上述步骤，我们就可以在 Python 中构建我们的分类器了。

在 Python 中构建分类器

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

朴素贝叶斯分类器

朴素贝叶斯是一种分类技术，用于使用贝叶斯定理构建分类器。假设预测变量是独立的。简而言之，它假设类中特定特征的存在与任何其他特征的存在无关。为了构建朴素贝叶斯分类器，我们需要使用名为 scikit learn 的 python 库。scikit 学习包下有三种朴素贝叶斯模型，分别是高斯模型、多项式模型和伯努利模型。

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

数据集

我们将使用名为Breast Cancer Wisconsin Diagnostic Database 的数据集。该数据集包括有关乳腺癌肿瘤的各种信息，以及恶性或良性的分类标签。该数据集包含 569 个肿瘤的 569 个实例或数据，并包含有关 30 个属性或特征的信息，例如肿瘤的半径、纹理、平滑度和面积。我们可以从 sklearn 包导入这个数据集。

朴素贝叶斯模型

为了构建朴素贝叶斯分类器，我们需要一个朴素贝叶斯模型。如前所述，scikit 学习包下有三种类型的朴素贝叶斯模型，分别是高斯模型、多项式模型和伯努利模型。在这里，在下面的示例中，我们将使用高斯朴素贝叶斯模型。

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

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

Import Sklearn

现在，我们需要导入名为 Breast Cancer Wisconsin Diagnostic Database 的数据集。

from sklearn.datasets import load_breast_cancer

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

data = load_breast_cancer()

数据可以组织如下 -

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

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

print(label_names)

上面的命令将分别打印出恶性和良性的类名。它显示为下面的输出 -

['malignant' 'benign']

现在，下面给出的命令将显示它们被映射到二进制值 0 和 1。这里 0 代表恶性癌症，1 代表良性癌症。它显示为下面的输出 -

print(labels[0])
0

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

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

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

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

为了在看不见的数据上测试我们的模型，我们需要将数据拆分为训练数据和测试数据。它可以在以下代码的帮助下完成 -

from sklearn.model_selection import train_test_split

上面的命令将从 sklearn 导入train_test_split函数，下面的命令将数据拆分为训练和测试数据。在下面的示例中，我们使用 40% 的数据进行测试，而重新挖掘的数据将用于训练模型。

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

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

from sklearn.naive_bayes import GaussianNB

上面的命令将导入GaussianNB模块。现在，使用下面给出的命令，我们需要初始化模型。

gnb = GaussianNB()

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

model = gnb.fit(train, train_labels)

现在，通过对测试数据进行预测来评估模型，可以按如下方式完成 -

preds = gnb.predict(test)print(preds)[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1
 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 
 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1 1 1 1 1 0 1 1 0 0 0 0 
 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0 1 1 0 0 0 
 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 
 1 0 0 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 
 1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 
 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 1 0 1]

上面的一系列 0 和 1 是肿瘤类别（即恶性和良性）的预测值。

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

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

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

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

支持向量机 (SVM)

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

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

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

数据集

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

核心

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

现在让我们导入以下包 -

import pandas as pdimport numpy as npfrom sklearn import svm, datasetsimport matplotlib.pyplot as plt

现在，加载输入数据 -

iris = datasets.load_iris()

我们正在采用前两个功能 -

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

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

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

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

C = 1.0

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

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

逻辑回归

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

在这里，如果我们谈论因变量和自变量，那么因变量就是我们要预测的目标类变量，而另一方面，自变量是我们要用来预测目标类的特征。

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

先决条件

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

现在，借助下面给出的代码，我们可以使用逻辑回归创建分类器 -

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

import numpy as npfrom sklearn import linear_modelimport matplotlib.pyplot as plt

现在，我们需要定义样本数据，可以按如下方式完成 -

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

接下来，我们需要创建逻辑回归分类器，可以按如下方式完成 -

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

最后但并非最不重要的是，我们需要训练这个分类器 -

Classifier_LR.fit(X, y)

现在，我们如何可视化输出？这可以通过创建一个名为 Logistic_visualize() 的函数来完成 -

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

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

mesh_step_size = 0.02

让我们定义 X 和 Y 值的网格如下 -

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

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

output = classifier.predict(np.c_[x_vals.ravel(), y_vals.ravel()])output = output.reshape(x_vals.shape)plt.figure()plt.pcolormesh(x_vals, y_vals, output, cmap = plt.cm.gray)
 plt.scatter(X[:, 0], X[:, 1], c = y, s = 75, edgecolors = 'black', linewidth=1, cmap = plt.cm.Paired)

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

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

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

决策树分类器

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

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

先决条件

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

现在，我们可以在以下 Python 代码的帮助下构建决策树分类器 -

首先，让我们按如下方式导入一些重要的库 -

import pydotplusfrom sklearn import treefrom sklearn.datasets import load_irisfrom sklearn.metrics import classification_reportfrom sklearn import cross_validationimport collections

现在，我们需要提供如下数据集 -

X = [[165,19],[175,32],[136,35],[174,65],[141,28],[176,15],[131,32],[166,6],[128,32],[179,10],[136,34],[186,2],[126,25],[176,28],[112,38],[169,9],[171,36],[116,25],[196,25]]Y = ['Man','Woman','Woman','Man','Woman','Man','Woman','Man','Woman','Man','Woman','Man','Woman','Woman','Woman','Man','Woman','Woman','Man']data_feature_names = ['height','length of hair']X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(X, Y, test_size=0.40, random_state=5)

提供数据集后，我们需要拟合模型，可以按如下方式完成 -

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

可以借助以下 Python 代码进行预测 -

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

我们可以借助以下 Python 代码可视化决策树 -

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

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

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

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

它将对上述代码的预测作为['Woman']并创建以下决策树 -

我们可以改变预测中的特征值来测试它。

随机森林分类器

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

导入必要的包 -

from sklearn.ensemble import RandomForestClassifierfrom sklearn.model_selection import train_test_splitfrom sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()import matplotlib.pyplot as pltimport numpy as np

现在，我们需要提供可以按以下方式完成的数据集 &minus

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

提供数据集后，我们需要拟合模型，可以按如下方式完成 -

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

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

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

输出

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

现在，与决策树一样，随机森林具有feature_importance模块，它将提供比决策树更好的特征权重视图。它可以绘制和可视化如下 -

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

分类器的性能

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

混淆矩阵

基本上它用于分类问题，其中输出可以是两种或多种类型的类。这是衡量分类器性能的最简单方法。混淆矩阵基本上是一个具有两个维度的表，即“实际”和“预测”。这两个维度都有“True Positives (TP)”、“True Negatives (TN)”、“False Positives (FP)”、“False Negatives (FN)”。

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

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

• True Positives - TP 是数据点的实际类别为 1 且预测也为 1 的情况。

• True Negatives - TNs 是数据点的实际类别为 0 且预测也为 0 的情况。

• False Positives - FPs 是数据点的实际类别为 0 而预测也为 1 的情况。

• 假阴性- FN 是数据点的实际类别为 1 而预测也为 0 的情况。

准确性

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

$$准确度 = rac{TP+TN}{TP+FP+FN+TN}$$

精确

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

$$精度 = rac{TP}{TP+FP}$$

召回或敏感性

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

$$召回 = rac{TP}{TP+FN}$$

特异性

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

$$特异性 = rac{TN}{TN+FP}$$

阶级失衡问题

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

不平衡类的例子

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

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

解决方案

平衡类的行为是解决不平衡类的方法。平衡类的主要目标是增加少数类的频率或减少多数类的频率。以下是解决不平衡类问题的方法 -

重采样

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

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

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

在这种情况下，我们从非欺诈实例中无替换地抽取 10% 的样本，然后将它们与欺诈实例结合起来 -

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

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

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

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

• Random Over-Sampling - 这种技术旨在通过复制它们来增加少数类中的实例数量来平衡类分布。

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

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

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

合奏技巧

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