Tutorialspoint Python 人工智能教程

来源：易百教程

人工智能（Python）教程™

与人类所的智能形成对比，人工智能是指机器所显示的智能。 本教程涵盖了人工神经网络，自然语言处理，机器学习，深度学习，遗传算法等各种人工智能领域的基本概念及其在Python中的如何实现。

面向读者

本教程将面向毕业生，毕业生和研究学生等那些对人工智能有兴趣，或者将人工智能作为课程的一部分人群而准备的。读者水平不限，可以是初学者或高级学习者。

前提条件

我们假设读者具有相关人工智能和Python编程的基本知识。 还应该了解AI中使用的基本术语以及一些有用的python软件包，如:nltk，OpenCV，pandas，OpenAI Gym等。

问题反馈

我们不能保证您在学习此人工智能(Python)教程的过程中不会遇到任何问题。本教程中的讲解，示例和代码等只是根据作者的理解来概括写出。由于作者水平和能力有限，因此不保正所有编写的文章都准确无误。但是如果有遇到任何错误或问题，请反馈给我们，我们会及时纠正以方便后续读者阅读。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

人工智能入门概念 - 人工智能（Python）教程™

自计算机或机器发明以来，它们执行各种任务的能力经历了指数增长。 人类在计算机系统的多样化工作领域发展越来越强大，计算机的速度不断提高，并且随着时间的推移缩小了规模。

计算机科学的一个分支叫做人工智能，它追求创造出像人一样聪明(智能)的计算机或机器。

人工智能的基本概念(AI)

根据人工智能之父John McCarthy的说法，它是“制造智能机器的科学和工程，特别是智能计算机程序”。

人工智能是一种以智能人类思维的类似方式的计算机，计算机控制的机器人或软件智能地思考的方法。 人工智能是通过研究人脑如何思考以及人类如何在解决问题的同时学习，决定和工作，然后将此研究的结果作为开发智能软件和系统的基础来完成的。

在利用计算机系统的强大功能时，人类的也会有好奇心:“机器能像人类一样思考和行为吗？”

因此，人工智能的发展始于在我们发现并认为在人类身上那些智能，也可以机器中类似的创造。

学习AI的必要性

正如我们所知，AI追求的是创造出像人一样聪明的机器。我们学习人工智能的理由有很多。 一些主要原因如下 -

• AI可以通过数据学习
  在我们的日常生活中，需要处理大量的数据，人类的大脑无法追踪这么多的数据。我们需要自动化处理这些事情。 为了实现自动化，我们需要学习AI，因为它可以从数据中学习，并且可以准确无误地完成重复任务。
• AI可以自学习
  一个系统应该能自学，因为数据本身不断变化，并且源于这些数据的知识必须不断更新。 我们可以使用AI来实现这个目的，因为启用AI的系统可以自学。
• AI可以实时响应
  人工智能借助神经网络可以更深入地分析数据。 由于这种能力，人工智能可以根据实时情况思考和响应情况。
• AI达到高准确度
  在深度神经网络的帮助下，AI可以达到极高的准确度。 AI有助于医学领域从患者的MRI中诊断癌症等疾病。
• 人工智能可以组织数据以最大限度地利用它
  数据是使用自学习算法的系统的知识产权。 我们需要人工智能以总是能够提供最佳结果的方式对数据进行索引和组织。
• 理解智能
  通过人工智能，可以构建智能系统。 我们需要理解智能的概念，以便我们的大脑可以构建像自己一样的另一个智能系统。

什么是智能？

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

智能类型
正如美国发展心理学家霍华德加德纳(Howard Gardner)所描述的，智能来自多方面，如下表所示 -

可以说一台机器或者一个系统至少配备一种或所有智能时是人工智能的。

智能组成有什么？

智能是无形的。 它由 -

• 推理
• 学习
• 解决问题
• 知觉
• 语言智能

下面简要介绍所有组件 -

推理

这是一套程序，使我们能够为判断，制定决策和预测提供基础。大致有两种类型 -

学习 - l

学习的能力被人类，动物的特定物种以及AI支持的系统所拥有。学习分类如下 -

听觉学习

它通过听力和听力来学习。 例如，听录音讲座的学生。

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

运动学习
它通过肌肉的精确运动来学习。 例如，挑选对象，写作等

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

感性学习
它是学习认识到，一个之前已经看到过的刺激。 例如，识别和分类对象和情况。

关系学习
它涉及在关系属性的基础上学习区分各种刺激，而不是绝对属性。 例如，在烹制上次咸的土豆时添加“少量少量”的盐，当因为当时加入一大汤匙盐。

• 空间学习 - 通过视觉刺激来学习，如图像，颜色，地图等。例如，一个人可以在实际跟随道路之前在脑海中创建路线图。
• 刺激反应学习 - 当某种刺激存在时，学习执行特定的行为。 例如，一只狗在听到门铃时抬起耳朵。

解决问题
人们通过走一条被已知或未知的障碍阻挡的道路，从现在的情况中感知并试图达到期望的解决方案。
解决问题还包括决策制定，即从多种选择中选择最合适的替代方案以达到预期目标的过程。

知觉
这是获取，解释，选择和组织感官信息的过程。
感知假设感知。在人类中，知觉受感觉器官的帮助。在人工智能的领域，感知机制以有意义的方式将传感器获取的数据放在一起。

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

人工智能涉及什么？

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

下面我们来看看AI研究的不同研究领域 -

机器学习
它是AI最受欢迎的领域之一。 这个领域的基本概念是让机器从数据中学习，因为人类可以从他/她的经验中学习。 它包含的学习模型的基础上，可以对未知数据进行预测。

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

搜索
这个研究领域基本上用于象棋，围棋等。 搜索算法在搜索整个搜索空间后给出最优解。

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

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

知识表示
这是研究领域，我们可以用机器可以理解的机器来表示事实。 代表更有效的知识; 更多的系统将是智能的。

AI的应用

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

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

专家系统
有一些应用程序集成了机器，软件和特殊信息来传递推理和建议。 他们向用户提供解释和建议。

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

• 间谍飞机拍摄照片，这些照片用于计算空间信息或地区地图。
• 医生使用临床专家系统来诊断患者。
• 警方使用计算机软件，可以通过法医艺术家存储的肖像识别罪犯的脸部。

语音识别
一些智能系统能够在人们对话时听到和理解语言的句子及其含义。 它可以处理不同的口音，俚语，背景中的噪音，由于寒冷造成的人类噪音变化等。

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

智能机器人
机器人能够执行人类给出的任务。 他们有传感器来检测真实世界的物理数据，如光，热，温度，运动，声音，碰撞和压力。 他们有高效的处理器，多个传感器和巨大的内存，展现智慧。 另外，他们能够从错误中学习，并能适应新的环境。

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

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

代理和环境

在本节中，我们将重点介绍代理和环境以及这些在人工智能中的帮助。

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

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

机器人代理取代了传感器的摄像头和红外测距仪，以及各种效应器的马达和执行器。

软件代理已将位串编码为其程序和操作。

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

相比之下，一些软件代理(软件机器人或softbots)存在于丰富的无限软域中。 模拟器有一个非常详细，复杂的环境。 软件代理需要实时从多种行为中进行选择。 Softbot旨在扫描客户的在线偏好，并向客户展示有趣的物品在真实以及人造环境中工作。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

人工智能开发环境配置 - 人工智能（Python）教程™

在本章中，我们将学习如何开始使用Python。也将理解Python如何为人工智能提供帮助。

为什么使用Python来开发AI

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

简单的语法和更少的编码
Python编程语言的简单语法非常简单，可用于开发AI应用程序。 由于此功能，测试可以更容易，我们可以更多地关注编程。

内置AI项目库
使用Python进行人工智能的一个主要优点是它内置了库。 Python有几乎所有种类的AI项目库。 例如，NumPy，SciPy，matplotlib，nltk，SimpleAI是一些重要的内置Python库。

• 开源 - Python是一种开源的编程语言。这使得它在社区中广泛流行。
• 可用于广泛的编程 - Python可用于广泛的编程任务，如小型shell脚本到企业Web应用程序。 这是Python适用于AI项目的另一个原因。

Python的特点

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

• 简单易学 - Python几乎没有关键字，结构简单，语法清晰。 这可以让学生快速掌握语言。
• 易于阅读 - Python代码更加清晰且易于阅读。
• 易于维护 - Python的源代码相当易于维护。
• 广泛的标准库 - Python的大部分库在UNIX，Windows和Macintosh上都非常便携且跨平台兼容。
• 交互模式 - Python支持交互模式，允许交互式测试和调试代码片段。
• 可移植 - Python可以在各种硬件平台上运行，并且在所有平台上具有相同的界面。
• 可扩展 - 可以将低级模块添加到Python解释器。 这些模块使程序员可以添加或定制他们的工具，以提高效率。
• 数据库 - Python为所有主要商业数据库提供接口。
• GUI编程 - Python支持可以创建并移植到许多系统调用，库和Windows系统(例如Windows MFC，Macintosh和Unix的X Window系统)的GUI应用程序。
• 可扩展 - 与shell脚本相比，Python为大型程序提供了更好的结构和支持。

Python的重要功能

现在来看看Python的以下重要特性 -

• 它支持功能和结构化编程方法以及OOP。
• 它可以用作脚本语言，或者可以编译为用于构建大型应用程序的字节码。
• 它提供非常高级的动态数据类型并支持动态类型检查。
• 它支持自动垃圾收集。
• 它可以很容易地与C，C++，COM，ActiveX，CORBA和Java集成。

安装Python

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

如果您的平台的二进制代码不可用，则需要使用C编译器手动编译源代码。 编译源代码为您选择安装时需要的功能提供了更多的灵活性。

有关Python的安装，请参考以下安装教程文章:

https://www.yiibai.com/python/python_environment.html

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

人工智能机器学习 - 人工智能（Python）教程™

学习意味着通过学习或经验获得知识或技能。 基于此，我们可以定义机器学习(ML)如下 -

它被定义为计算机科学领域，更具体地说是人工智能的应用，它提供计算机系统学习数据和改进经验而不被明确编程的能力。

基本上，机器学习的主要重点是让电脑自动学习，无需人工干预。 现在的问题是，如何开始这样的学习并完成？ 它可以从数据观察开始。 数据可以是一些例子，指导或一些直接的经验。 然后在这个输入的基础上，机器通过查找数据中的一些模式来做出更好的决定。

机器学习的类型(ML)

机器学习算法有助于计算机系统学习，而无需明确编程。 这些算法分为有监督或无监督。 现在让我们来看看几个常见的算法 -

监督机器学习算法

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

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

Y = f(x)

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

主要监督问题可分为以下两类问题 -

• 分类 - 当有“黑色”，“教学”，“非教学”等分类输出时，问题被称为分类问题。
• 回归 - 当拥有“距离”，“千克”等真实值输出时，问题就称为回归问题。

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

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

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

简而言之，可以说在无监督学习中，没有正确的答案，也没有教师指导。 算法有助于发现数据中有趣的模式。

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

• 聚类 - 在聚类问题中，我们需要发现数据中的固有分组。 例如，按顾客的购买行为分组。
• 关联 - 一个问题称为关联问题，因为这类问题需要发现描述大部分数据的规则。 例如，找到同时购买x和y商品的顾客。

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

增强机器学习算法
这些机器学习算法的使用量非常少。 这些算法训练系统做出特定的决定。 基本上，机器暴露在使用试错法不断训练自己的环境中。 这些算法从过去的经验中学习并尝试捕获最佳可能的知识以做出准确的决策。 马尔可夫决策过程就是增强机器学习算法的一个例子。

最常见的机器学习算法

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

线性回归
它是统计和机器学习中最着名的算法之一。

基本概念 - 主要是线性回归是一个线性模型，假设输入变量x和单个输出变量y之间的线性关系。 换句话说，y可以由输入变量x的线性组合来计算。 变量之间的关系可以通过拟合最佳线来确定。

线性回归的类型

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

• 简单线性回归 - 如果线性回归算法只有一个独立变量，则称为简单线性回归。
• 多元线性回归 - 如果线性回归算法具有多个独立变量，则称其为多元线性回归。

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

Logistic回归
它是一种分类算法，也称为logit回归。

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

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

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

支持向量机(SVM)

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

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

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

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

K-最近邻居(KNN)

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

• 计算上KNN比用于分类问题的其他算法昂贵。
• 变量的规范化需要其他更高的范围变量可以偏差。
• 在KNN中，需要在噪音消除等预处理阶段进行工作。

K均值聚类

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

• K-means为每个簇选取k个点，称为质心。
• 每个数据点形成具有最接近质心的群集，即k个群集。
• 它将根据现有集群成员查找每个集群的质心。
• 需要重复这些步骤直到收敛。

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

• 随机森林分类器可用于分类和回归任务。
• 可以处理缺失的值。
• 即使在森林中有更多的树，它也不会过度适合模型。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

人工智能数据准备 - 人工智能（Python）教程™

在上一节中，我们已经学习了监督和无监督机器学习算法。 这些算法需要格式化数据才能开始训练过程。在这一节中，我们以某种方式准备或格式化数据，以便将其作为ML算法的输入提供。

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

预处理数据

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

数据预处理步骤

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

第1步 - 导入有用的软件包 - 如果使用Python，那么这将成为将数据转换为特定格式(即预处理)的第一步。如下代码 -

import numpy as np
sklearn import 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]])

第3步 - 应用预处理技术 - 在这一步中，我们需要应用预处理技术。

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

数据预处理技术

下面介绍数据预处理技术 -

二值化

这是当需要将数值转换为布尔值时使用的预处理技术。我们可以用一种内置的方法来二值化输入数据，比如说用0.5作为阈值，方法如下 -

data_binarized = preprocessing.Binarizer(threshold = 0.5).transform(input_data)
print("\nBinarized data:\n", 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 ("\nMin max scaled data:\n", 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("\nL1 normalized data:\n", data_normalized_l1)

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

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("\nL2 normalized data:\n", 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中对数据标记进行编码 -

第1步 - 导入有用的软件包

如果使用Python，那么这将是将数据转换为特定格式(即预处理)的第一步。 它可以做到如下 -

import numpy as np
from sklearn import preprocessing

第2步 - 定义样本标签

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

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

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

在这一步中，我们需要创建标签编码器并对其进行训练。 以下是Python代码的实现 -

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

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

LabelEncoder()

第4步 - 通过编码随机排序列表来检查性能

此步骤可用于通过编码随机排序列表来检查性能。 下面的Python代码可以做同样的事情 -

# encoding a set of labels
test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", 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("\nEncoded values =", encoded_values)

现在，将被打印如下 -

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

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

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

标记与未标记数据

未标记的数据主要由自然或人造物体的样本组成，这些样本可以很容易从现实世界中获得。 它们包括音频，视频，照片，新闻文章等。

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

有很多情况下，无标签数据丰富且容易获得，但标注数据通常需要人工/专家进行注释。 半监督学习尝试将标记数据和未标记数据组合起来，以建立更好的模型。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

人工智能监督学习(分类) - 人工智能（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学习包中，有三种类型的朴素贝叶斯模型被称为Gaussian，Multinomial和Bernoulli。

要构建朴素贝叶斯机器学习分类器模型，需要以下“减号”

数据集

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

朴素贝叶斯模型

为了构建朴素贝叶斯分类器，需要一个朴素贝叶斯模型。 如前所述，scikit学习包中有三种类型的NaïveBayes模型，分别称为Gaussian，Multinomial和Bernoulli。 在下面的例子中，将使用高斯朴素贝叶斯模型。

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

首先，我们需要安装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

上述命令将从sklearn中导入train_test_split函数，下面的命令将数据分解为训练和测试数据。 在下面的例子中，我们使用40%的数据进行测试，并将提示数据用于训练模型。

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

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

from sklearn.naive_bayes import GaussianNB

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

gnb = GaussianNB()

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

model = gnb.fit(train, train_labels)

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

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

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

上述0和1系列是肿瘤类别的预测值，即恶性和良性。

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

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

结果显示NaïveBayes分类器准确率为95.17%。

这是基于NaïveBayse高斯模型的机器学习分类器。

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

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

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

数据集

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

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

现在导入下列软件包 -

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

现在，加载输入数据 -

iris = datasets.load_iris()

我们使用前两个功能 -

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

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

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

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

C = 1.0

需要创建SVM分类器对象。参考以下代码 -

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

执行后得到以下结果 -

逻辑回归

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

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

在逻辑回归中，估计概率意味着预测事件的可能性发生。例如，店主想要预测进入商店的顾客将购买站或不购物。逻辑函数是用来构建具有各种参数的函数的S形曲线。

前提条件

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

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

首先，导入一些软件包 -

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

现在，需要定义可以完成的样本数据，如下所示 -

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

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

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

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

Classifier_LR.fit(X, y)

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

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

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

mesh_step_size = 0.02

下面定义X和Y值的网格，如下所示 -

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

使用以下代码，可以在网格网格上运行分类器 -

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

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

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

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

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

　决策树分类器

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

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

前提条件

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

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

首先，导入一些重要的库如下 -

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

现在，提供如下数据集 -

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

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

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

在提供数据集之后，需要拟合可以如下完成的模型 -

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

预测可以使用以下Python代码来完成 -

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

使用以下Python代码来实现可视化决策树 -

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

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

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

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

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

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

随机森林分类器

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

导入必要的软件包 -

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

现在，需要按照以下方式提供数据集

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

在提供数据集之后，需要拟合可以如下完成的模型 -

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

现在，获得训练以及测试子集的准确性:如果增加估计器的数量，那么测试子集的准确性也会增加。

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

上面代码，输出结果如下所示 -

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

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

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

执行上面代码，得到以下输出结果 -

分类器的性能

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

混乱矩阵

基本上它用于输出可以是两种或更多种类的分类问题。 这是衡量分类器性能的最简单方法。 混淆矩阵基本上是一个包含两个维度即“实际”和“预测”的表格。 这两个维度都有“真正的正面(TP)”，“真正的负面(TN)”，“错误的正面(FP)”，“错误的否定(FN)”。

在上面的混淆矩阵中，1表示正类，0表示负类。
以下是与混淆矩阵相关的术语 -

• 真正 - 当实际的数据点类别为1并且预测也为1时，TP就是这种情况。
• 真负 - 当数据点的实际类别为0并且预测也为0时，TN就是这种情况。
• 假正 - 当实际的数据点类别为0并且预测也为1时，FP就是这种情况。
• 假负 - FN是数据点的实际类别为1且预测也为0的情况。

准确性

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

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

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

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

分类失衡问题

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

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

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

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

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

• 随机抽样 - 这项技术旨在通过随机排除大多数类别的例子来平衡课堂分布。 这样做直到大多数和少数群体的实例得到平衡。

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

在这种情况下，我们将10%的样本从非欺诈实例中取而代之，然后将它们与欺诈实例相结合 -
随机抽样后的非欺诈性观察:4950的10% = 495
将他们与欺诈观察结合后的总观测值: 50 + 495 = 545

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

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

• 随机抽样 - 这种技术旨在通过复制少数类中的实例数量来平衡类分布。

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

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

这种方法的主要优点是不会丢失有用的信息。 但另一方面，由于它复制了少数族群的事件，因此它有更多的过度机会。

合奏技巧

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

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

人工智能监督学习(回归) - 人工智能（Python）教程™

回归是最重要的统计和机器学习工具之一。 我们认为机器学习的旅程从回归开始并不是错的。 它可以被定义为使我们能够根据数据做出决定的参数化技术，或者换言之，允许通过学习输入和输出变量之间的关系来基于数据做出预测。 这里，依赖于输入变量的输出变量是连续值的实数。 在回归中，输入和输出变量之间的关系很重要，它有助于我们理解输出变量的值随输入变量的变化而变化。 回归常用于预测价格，经济，变化等。

在Python中构建回归器

在本节中，我们将学习如何构建单一以及多变量回归器。

线性回归器/单变量回归器

让我们重点介绍一些必需的软件包 -

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

现在，我们需要提供输入数据，并将数据保存在名为linear.txt的文件中。

input = 'D:/ProgramData/linear.txt'

使用np.loadtxt函数加载这些数据。

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

下一步将是培训模型。下面给出培训和测试样本。

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:]

现在，我们需要创建一个线性回归器对象。

reg_linear = linear_model.LinearRegression()

用训练样本训练对象。

reg_linear.fit(X_train, y_train)

下面使用测试数据做预测。

y_test_pred = reg_linear.predict(X_test)

现在绘制并可视化数据。

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

执行上面示例代码，输出以下结果 -

现在，我们可以计算线性回归的性能如下 -

print("Performance of Linear regressor:")
print("Mean absolute error =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error =", 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))

线性回归器的性能输出结果如下 -

Mean absolute error = 1.78
Mean squared error = 3.89
Median absolute error = 2.01
Explain variance score = -0.09
R2 score = -0.09

在上面的代码中，我们使用了这些小数据源。 如果想要处理一些大的数据集，那么可以使用sklearn.dataset来导入更大的数据集。

2,4.82.9,4.72.5,53.2,5.56,57.6,43.2,0.92.9,1.92.4,
3.50.5,3.41,40.9,5.91.2,2.583.2,5.65.1,1.54.5,
1.22.3,6.32.1,2.8

多变量回归
首先，让我们导入一些必需的软件包 -

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

现在，需要提供输入数据，并将数据保存在名为linear.txt的文件中。

input = 'D:/ProgramData/Mul_linear.txt'

我们将通过使用np.loadtxt函数加载这些数据。

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

下一步将是训练模型; 会提供训练和测试样品数据。

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:]

现在，我们需要创建一个线性回归器对象。

reg_linear_mul = linear_model.LinearRegression()

用训练样本训练对象。

reg_linear_mul.fit(X_train, y_train)

现在，最后需要用测试数据做预测。

y_test_pred = reg_linear_mul.predict(X_test)

print("Performance of Linear regressor:")
print("Mean absolute error =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error =", 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))

线性回归器的性能输出结果如下 -

Mean absolute error = 0.6
Mean squared error = 0.65
Median absolute error = 0.41
Explain variance score = 0.34
R2 score = 0.33

现在，我们将创建一个10阶多项式并训练回归器。并提供样本数据点。

polynomial = PolynomialFeatures(degree = 10)
X_train_transformed = polynomial.fit_transform(X_train)
datapoint = [[2.23, 1.35, 1.12]]
poly_datapoint = polynomial.fit_transform(datapoint)

poly_linear_model = linear_model.LinearRegression()
poly_linear_model.fit(X_train_transformed, y_train)
print("\nLinear regression:\n", reg_linear_mul.predict(datapoint))
print("\nPolynomial regression:\n", poly_linear_model.predict(poly_datapoint))

线性回归 -

[2.40170462]

多项式回归 -

[1.8697225]

在上面的代码中，我们使用了这些小数据。 如果想要一个大的数据集，那么可以使用sklearn.dataset来导入一个更大的数据集。

2,4.8,1.2,3.22.9,4.7,1.5,3.62.5,5,2.8,23.2,5.5,3.5,2.16,5,
2,3.27.6,4,1.2,3.23.2,0.9,2.3,1.42.9,1.9,2.3,1.22.4,3.5,
2.8,3.60.5,3.4,1.8,2.91,4,3,2.50.9,5.9,5.6,0.81.2,2.58,
3.45,1.233.2,5.6,2,3.25.1,1.5,1.2,1.34.5,1.2,4.1,2.32.3,
6.3,2.5,3.22.1,2.8,1.2,3.6

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

人工智能逻辑编程 - 人工智能（Python）教程™

在本章中，我们将重点介绍逻辑编程以及它在人工智能中的作用。

我们已经知道逻辑是对正确推理原则的研究，或者简单地说就是研究什么是什么。 例如，如果两个陈述是真的，那么我们可以从中推断出任何第三个陈述。

概念
逻辑编程是两个字，逻辑和编程的组合。 逻辑编程是一种编程模式，其中问题通过程序语句表达为事实和规则，但在形式逻辑系统中。 就像面向对象，函数式，声明式和程序式等其他编程模式一样，它也是编程方法的一种特殊方式。

如何用逻辑编程解决问题

逻辑编程使用事实和规则来解决问题。 这就是为什么他们被称为逻辑编程的基石。 在逻辑编程中需要为每个程序指定一个目标。要理解在逻辑编程中如何解决问题，我们需要了解构建块 - 事实和规则 -

事实
实际上，每个逻辑程序都需要事实来处理，以达到既定目标。 事实上基本上是关于计划和数据的真实陈述。 例如，北京是中国的首都。

规则
实际上，规则是允许我们对问题域做出结论的约束条件。 规则基本上写成逻辑条款来表达各种事实。 例如，如果构建，那么必须定义所有规则。

规则对于解决逻辑编程中的任何问题都非常重要。 规则基本上是可以表达事实的合乎逻辑的结论。 以下是规则的语法 -

A∶− B1,B2,...,Bn.

在这里，A是头部，B1，B2，… Bn是主体。

例如 - ancestor(X，Y): - father(X，Y)。

ancestor(X，Z): - father(X，Y)，ancestor(Y，Z)。

对于每一个X和Y，如果X是Y的父亲，Y是Z的祖先，那么X是Z的祖先。对于每个X和Y，X是Z的祖先，如果X是 Y和Y的父亲是Z的祖先。

安装必需的包

为了在Python中开始逻辑编程，需要安装以下两个包 -

Kanren
它为我们提供了一种简化业务逻辑编写代码的方式。 它让我们用规则和事实来表达逻辑。 以下命令来安装kanren -

pip install kanren

SymPy
SymPy是符号数学的Python库。 它旨在成为一个全功能的计算机代数系统(CAS)，同时保持代码尽可能简单，以便易于理解和扩展。 以下命令是用来安装SymPy -

pip install sympy

逻辑编程的例子

以下是一些可以通过逻辑编程解决的例子 -

匹配数学表达式

实际上，我们可以通过使用逻辑编程以非常有效的方式找到未知值。 以下Python代码用于匹配数学表达式 -

考虑先导入下列软件包 -

from kanren import run, var, fact
from kanren.assoccomm import eq_assoccomm as eq
from kanren.assoccomm import commutative, associative

需要定义要使用的数学运算 -

add = 'add'
mul = 'mul'

加法和乘法都是交互进程。 因此，我们需要指定它，这可以按照以下方式完成 -

fact(commutative, mul)
fact(commutative, add)
fact(associative, mul)
fact(associative, add)

定义变量是强制性的; 这可以如下完成 -

a, b = var('a'), var('b')

需要将表达式与原始模式相匹配。有以下原始模式，基础是(5 + a)* b-

Original_pattern = (mul, (add, 5, a), b)

有以下两个表达式来匹配原始模式 -

exp1 = (mul, 2, (add, 3, 1))
exp2 = (add,5,(mul,8,1))

输出可以使用以下命令打印 -

print(run(0, (a,b), eq(original_pattern, exp1)))
print(run(0, (a,b), eq(original_pattern, exp2)))

运行此代码后，将得到以下输出 -

((3,2))
()

第一个输出表示a和b的值。 第一个表达式匹配原始模式并返回a和b的值，但第二个表达式与原始模式不匹配，因此没有返回任何内容。

查找素数

在逻辑编程的帮助下，可以从数字列表中出素数，也可以生成素数。 下面给出的Python代码将从数字列表中找到素数，并且还会生成前10个素数。

首先导入以下软件包 -

from kanren import isvar, run, membero
from kanren.core import success, fail, goaleval, condeseq, eq, var
from sympy.ntheory.generate import prime, isprime
import itertools as it

现在，我们将定义一个名为prime_check的函数，它将根据给定的数字检查素数作为数据。

def prime_check(x):
if isvar(x):
return condeseq([(eq,x,p)] for p in map(prime, it.count(1)))
else:
return success if isprime(x) else fail

现在，声明一个变量 -

x = var()
print((set(run(0,x,(membero,x,(12,14,15,19,20,21,22,23,29,30,41,44,52,62,65,85)),
(prime_check,x)))))
print((run(10,x,prime_check(x))))

上述代码的输出如下 -

{19, 23, 29, 41}
(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)

解决难题

逻辑编程可用于解决许多问题，如8拼图，斑马拼图，数独，N皇后等。在这里，举例说明斑马拼图的变体如下 -

有五间房子。
英国人住在红房子里。
瑞典人有一只狗。
丹麦人喝茶。
绿房子在白房子的左边。
他们在绿房子里喝咖啡。
吸Pall Mall的人有鸟。
吸Dunhill在的人黄色房子里。
在中间的房子里，他们喝牛奶。
挪威人住在第一宫。
那个抽Blend的男人住在猫屋旁边的房子里。
在他们有一匹马的房子旁边的房子里，他们吸Dunhill烟。
抽Blue Master的人喝啤酒。
德国人吸Prince烟。
挪威人住在蓝房子旁边。
他们在房子旁边的房子里喝水，在那里吸Blend烟。

在Python的帮助下解决谁有斑马的问题。
导入必要的软件包 -

from kanren import *
from kanren.core import lall
import time

现在，我们需要定义两个函数 - left()和next()来查找哪个房屋左边或接近谁的房子 -

def left(q, p, list):
return membero((q,p), zip(list, list[1:]))
def next(q, p, list):
return conde([left(q, p, list)], [left(p, q, list)])

现在，声明一个变量:houses，如下 -

houses = var()

需要在lall包的帮助下定义规则如下。

有5间房子 -

rules_zebraproblem = lall(
(eq, (var(), var(), var(), var(), var()), houses),

(membero,('Englishman', var(), var(), var(), 'red'), houses),
(membero,('Swede', var(), var(), 'dog', var()), houses),
(membero,('Dane', var(), 'tea', var(), var()), houses),
(left,(var(), var(), var(), var(), 'green'),
(var(), var(), var(), var(), 'white'), houses),
(membero,(var(), var(), 'coffee', var(), 'green'), houses),
(membero,(var(), 'Pall Mall', var(), 'birds', var()), houses),
(membero,(var(), 'Dunhill', var(), var(), 'yellow'), houses),
(eq,(var(), var(), (var(), var(), 'milk', var(), var()), var(), var()), houses),
(eq,(('Norwegian', var(), var(), var(), var()), var(), var(), var(), var()), houses),
(next,(var(), 'Blend', var(), var(), var()),
(var(), var(), var(), 'cats', var()), houses),
(next,(var(), 'Dunhill', var(), var(), var()),
(var(), var(), var(), 'horse', var()), houses),
(membero,(var(), 'Blue Master', 'beer', var(), var()), houses),
(membero,('German', 'Prince', var(), var(), var()), houses),
(next,('Norwegian', var(), var(), var(), var()),
(var(), var(), var(), var(), 'blue'), houses),
(next,(var(), 'Blend', var(), var(), var()),
(var(), var(), 'water', var(), var()), houses),
(membero,(var(), var(), var(), 'zebra', var()), houses)
)

现在，用前面的约束运行解算器 -

solutions = run(0, houses, rules_zebraproblem)

借助以下代码，可以提取解算器的输出 -

output_zebra = [house for house in solutions[0] if 'zebra' in house][0][0]

以下代码将打印解决方案 -

print ('\n'+ output_zebra + 'owns zebra.')

上述代码的输出如下 -

German owns zebra.

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

人工智能无监督学习：聚类 - 人工智能（Python）教程™

无监督机器学习算法没有任何监督者提供任何指导。 这就是为什么它们与真正的人工智能紧密结合的原因。

在无人监督的学习中，没有正确的答案，也没有监督者指导。 算法需要发现用于学习的有趣数据模式。

什么是聚类？

基本上，它是一种无监督学习方法，也是用于许多领域的统计数据分析的常用技术。 聚类主要是将观测集合划分为子集(称为聚类)的任务，以同一聚类中的观测在一种意义上相似并且与其他聚类中的观测不相似的方式。 简而言之，可以说聚类的主要目标是根据相似性和不相似性对数据进行分组。

例如，下图显示了不同群集中的类似数据 -

数据聚类算法

以下是数据聚类的几种常用算法 -

K-Means算法
K均值聚类算法是众所周知的数据聚类算法之一。 我们需要假设簇的数量已经是已知的。 这也被称为平面聚类。 它是一种迭代聚类算法。 该算法需要遵循以下步骤 -

第1步 - 需要指定所需的K个子组的数量。
第2步 - 修复群集数量并将每个数据点随机分配到群集。 换句话说，我们需要根据群集数量对数据进行分类。

在这一步中，计算聚类质心。

由于这是一种迭代算法，因此需要在每次迭代中更新K个质心的位置，直到找到全局最优值或换句话说质心到达其最佳位置。

以下代码将有助于在Python中实现K-means聚类算法。 我们将使用Scikit-learn模块。

导入必需的软件包 -

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

以下代码行将通过使用sklearn.dataset包中的make_blob来生成包含四个blob的二维数据集。

from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4,
cluster_std = 0.40, random_state = 0)

可以使用下面的代码可视化数据集 -

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

得到以下结果 -

在这里，将kmeans初始化为KMeans算法，以及多少个群集(n_clusters)所需的参数。

kmeans = KMeans(n_clusters = 4)

需要用输入数据训练K-means模型。

kmeans.fit(X)
y_kmeans = kmeans.predict(X)
plt.scatter(X[:, 0], X[:, 1], c = y_kmeans, s = 50, cmap = 'viridis')

centers = kmeans.cluster_centers_

下面给出的代码将根据数据绘制和可视化机器的发现，并根据要找到的聚类数量进行拟合。

plt.scatter(centers[:, 0], centers[:, 1], c = 'black', s = 200, alpha = 0.5);
plt.show()

得到以下结果 -

均值偏移算法

它是另一种在无监督学习中使用的流行和强大的聚类算法。 它不做任何假设，因此它是非参数算法。 它也被称为分层聚类或均值聚类分析。 以下将是该算法的基本步骤 -

• 首先，需要从分配给它们自己的集群的数据点开始。
• 现在，它计算质心并更新新质心的位置。
• 通过重复这个过程，向簇的顶点靠近，即朝向更高密度的区域移动。
• 该算法停止在质心不再移动的阶段。

在下面的代码的帮助下，在Python中实现了Mean Shift聚类算法。使用Scikit-learn模块。

导入必要的软件包 -

import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")

以下代码将通过使用sklearn.dataset包中的make_blob来生成包含四个blob的二维数据集。

from sklearn.datasets.samples_generator import make_blobs

可以用下面的代码可视化数据集 -

centers = [[2,2],[4,5],[3,10]]
X, _ = make_blobs(n_samples = 500, centers = centers, cluster_std = 1)
plt.scatter(X[:,0],X[:,1])
plt.show()

执行上面示例代码，得到以下结果 -

现在，我们需要用输入数据来训练Mean Shift聚类模型。

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_)
[[ 3.23005036 3.84771893]
[ 3.02057451 9.88928991]]
Estimated clusters: 2

下面给出的代码将有助于根据数据绘制和可视化机器的发现，并根据要找到的聚类数量进行装配。

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 = 10)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
marker = "x",color = 'k', s = 150, linewidths = 5, zorder = 10)
plt.show()

执行上面示例代码，得到以下结果 -

测量群集性能

现实世界的数据不是自然地组织成许多独特的群集。 由于这个原因，要想象和推断推理并不容易。 这就是为什么需要测量聚类性能及其质量。 它可以在轮廓分析的帮助下完成。

轮廓分析

该方法可用于通过测量群集之间的距离来检查聚类的质量。 基本上，它提供了一种通过给出轮廓分数来评估像集群数量这样的参数的方法。 此分数是衡量一个群集中每个点与相邻群集中的点的距离的度量。

分析轮廓分数
得分范围为[-1，1]。 以下是对这个分数的分析 -

• 得分为+1分 - 得分接近+1表示样本距离相邻集群很远。
• 得分为0分 - 得分0表示样本与两个相邻群集之间的决策边界处于或非常接近。
• 得分为-1分 - 得分为负分数表示样本已分配到错误的群集。

计算轮廓分数

在本节中，我们将学习如何计算轮廓分数。

轮廓分数可以通过使用以下公式来计算 -

这里，`

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

自然语言处理 - 人工智能（Python）教程™

自然语言处理(NLP)是指使用诸如英语之类的自然语言与智能系统进行通信的AI方法。

如果您希望智能系统(如机器人)按照您的指示执行操作，希望听取基于对话的临床专家系统的决策时，则需要处理自然语言。

NLP领域涉及使计算机用人类使用的自然语言执行有用的任务。 NLP系统的输入和输出可以是 -

• 言语(说话)
• 书面文字

NLP的组成部分

在本节中，我们将了解NLP的不同组件。 NLP有两个组件。 这些组件如下所述 -

1. 自然语言理解(NLU)

它涉及以下任务 -

• 将给定的自然语言输入映射为有用的表示。
• 分析语言的不同方面。

2. 自然语言生成(NLG)

它是从一些内部表现形式以自然语言的形式产生有意义的短语和句子的过程。 它涉及 -

• 文字规划 - 这包括从知识库中检索相关内容。
• 句子规划 - 这包括选择所需的单词，形成有意义的短语，设定句子的语气。
• 文本实现 - 这是将句子计划映射到句子结构。

NLU的难点

NLU的形式和结构非常丰富， 然而，它是不明确的。 可能会有不同程度的模糊性 -

词汇含糊不清
它处于一个非常原始的层面，如单词级别。 例如，将单词“board”视为名词或动词？

语法级别歧义
一个句子可以用不同的方式解析。 例如，“他用红色帽子举起甲虫。” - 他用帽子举起甲虫，还是举起了一顶带有红色帽子的甲虫？

参照歧义
参考使用代词的东西。 例如，里马去了高里。 她说，“我累了。” - 究竟是谁累？

NLP术语

现在让我们看看NLP术语中的一些重要术语。

• 音韵 - 这是系统地组织声音的研究。
• 形态 - 这是建设从原始的有意义的单位的话的研究。
• 语素 - 它是语言中意义的原始单位。
• 语法 - 它是指安排单词来表达一个句子。 它还涉及确定单词在句子和短语中的结构作用。
• 语义 - 它涉及单词的含义以及如何将单词组合成有意义的短语和句子。
• 语用学 - 它处理在不同情况下使用和理解句子以及句子的解释如何受到影响。
• 话语 - 它处理前面的句子如何影响下一句话的解释。
• 世界知识 - 它包括关于世界的一般知识。

NLP步骤

本节介绍NLP中的分析步骤。

词汇分析
它涉及识别和分析单词的结构。 语言的词汇表示语言中的单词和短语的集合。 词法分析将整个txt块分成段落，句子和单词。

句法分析(解析)
它涉及分析句子中的单词，语法和安排单词的方式，以显示单词之间的关系。“The school goes to boy”等句子被英语句法分析器拒绝。

语义分析
它从文本中提取确切含义或字典含义。 文本被检查是否有意义。 它通过映射任务域中的语法结构和对象来完成。语义分析器忽视诸如“热冰淇淋”之类的句子。

话语整合
任何句子的含义都取决于在它之前的句子的含义。 此外，它也带来了紧接着的后续句子的含义。

语用分析
在此期间，所说的重新解释了它的实际意义。 它涉及推导需要真实世界知识的语言方面。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

NLTK包 - 人工智能（Python）教程™

在本章中，我们将学习如何开始使用自然语言工具包(软件包)。

前提条件

如果想用自然语言处理来构建应用程序，那么上下文中的变化就会使其变得非常困难。 语境因素影响机器如何理解特定句子。 因此，我们需要通过使用机器学习方法来开发自然语言应用程序，以便机器也能够理解人类可以理解上下文的方式。

要构建这样的应用程序，我们将使用名为NLTK(自然语言工具包包)的Python包。

导入NLTK

在使用之前需要安装NLTK，它可以在以下命令来安装 -

pip install nltk

要为NLTK构建conda包，请使用以下命令 -

conda install -c anaconda nltk

现在安装NLTK包后，需要通过python命令提示符导入。通过在Python命令提示符下编写以下命令来导入它 -

>>> import nltk

下载NLTK的数据

现在导入NLTK后，我们还需要下载所需的数据。 它可以在Python命令提示符下通过以下命令完成 -

>>> nltk.download()

安装其他必需的软件包

为了使用NLTK构建自然语言处理应用程序，需要安装必要的软件包。如下 -

gensim

它是一个强大的语义建模库，对许多应用程序很有用。可以通过执行以下命令来安装它 -

pip install gensim

pattern

它用于使gensim包正常工作。可以通过执行以下命令来安装它 -

pip install pattern

标记化，词干化和词形化的概念

在本节中，我们将了解什么是标记化，词干化和词形化。

1. 标记化

它可以被定义为将给定文本即字符序列分成称为令牌的较小单元的过程。令牌可以是单词，数字或标点符号。 它也被称为分词。 以下是标记化的一个简单示例 -

输入 - 芒果，香蕉，菠萝和苹果都是水果。

输出 -

打断给定文本的过程可以通过查找单词边界来完成。 单词的结尾和新单词的开头称为单词边界。 文字的书写体系和印刷结构会影响边界。

在Python NLTK模块中，有与标记化有关的不同包，可以根据需要将文本划分为标记。 一些软件包如下所示 -

sent_tokenize包

顾名思义，这个软件包会将输入文本分成几个句子。 可以使用下面的Python代码导入这个包 -

from nltk.tokenize import sent_tokenize

word_tokenize包

这个包将输入文本分成单词。可以使用下面的Python代码来导入这个包 -

from nltk.tokenize import word_tokenize

WordPuncttokenizer包

这个包将输入文本分成单词和标点符号。可以使用下面的Python代码来导入这个包 -

from nltk.tokenize import WordPuncttokenizer

2. 词干

在处理文字时，由于语法原因，我们遇到了很多变化。 这里的变化的概念意味着必须处理像:democracy, democratic 和 democratization 等不同形式的相同词汇。机器非常需要理解这些不同的单词具有相同的基本形式。 通过这种方式，在分析文本的同时提取单词的基本形式将会很有用。

我们可以通过阻止来实现这一点。 通过这种方式，可以说干扰是通过切断单词的结尾来提取单词基本形式的启发式过程。

在Python NLTK模块中，有一些与stemming相关的其它包。 这些包可以用来获取单词的基本形式。 这些软件包使用算法。 一些软件包如下所示 -

PorterStemmer包

这个Python包使用Porter算法来提取基础表单。可以使用下面的Python代码来这个包 -

from nltk.stem.porter import PorterStemmer

例如，如果将writing这个词作为这个词干的输入，它们就会在词干之后得到write这个词。

LancasterStemmer包

这个Python包将使用Lancaster的算法来提取基本形式。 可以使用下面的Python代码来导入这个包 -

from nltk.stem.lancaster import LancasterStemmer

例如，如果将writing这个词作为这个词干的输入，它们就会在词干之后得到write这个词。

SnowballStemmer包

这个Python包将使用雪球算法来提取基本形式。 可以使用下面的Python代码来导入这个包 -

from nltk.stem.snowball import SnowballStemmer

例如，如果将writing这个词作为这个词干的输入，它们就会在词干之后得到write这个词。

所有这些算法都有不同程度的严格性。 如果比较这三个词干的话，那么波特词干是最不严格的，兰卡斯特词干是最严格的。 雪球词干在速度和严格性方面都很好用。

词形还原

也可以通过词形化来提取单词的基本形式。 它基本上通过使用词汇的词汇和形态分析来完成这项任务，通常旨在仅删除变元结尾。 任何单词的这种基本形式都称为引理。

词干化和词性化的主要区别在于词汇的使用和形态分析。 另一个区别是，词干最常见的是崩溃派生相关的词汇，而词素化通常只会折拢引理的不同的折点形式。 例如，如果提供单词saw作为输入词，那么词干可能会返回单词's'，但词形化会尝试返回单词，看看或看到取决于使用该单词是动词还是名词。

在Python NLTK模块中，有以下与词形化过程有关的包，可以使用它来获取词的基本形式 -

WordNetLemmatizer包

这个Python包将提取单词的基本形式，取决于它是用作名词还是动词。 可以使用下面的Python代码的来导入这个包 -

from nltk.stem import WordNetLemmatizer

块化:将数据分割成块

它是自然语言处理中的重要过程之一。 分块的主要工作是识别词类和短语，如名词短语。 我们已经研究了令牌化的过程，即令牌的创建。 分块基本上就是这些令牌的标签。 换句话说，组块会告诉我们句子的结构。

在下面的章节中，我们将学习不同类型的分块。

组块的类型

有两种类型的组块。 类型如下 -

• 上分块
  在这个组块过程中，对象，事物等向更普遍的方向发展，语言变得更加抽象。 有更多的协议机会。 在这个过程中缩小。 例如，如果将“汽车是为了什么目的”这个问题大肆渲染？我们可能会得到答案是:“运输”。
• 下分块
  在这个组块过程中，对象，事物等朝着更具体的方向发展，语言更加渗透。 更深层次的结构将进行仔细检查。 在这个过程中会放大。例如，如果将“专门讲述一辆汽车”这个问题归纳起来？ 会得到关于汽车的更小的信息。

示例

在这个例子中，我们将通过使用Python中的NLTK模块来进行Noun-Phrase chunking，这是一种chunking类别，它可以在句子中找到名词短语块，

在python中执行这些步骤来实现名词短语分块 -

第1步 - 在这一步中，需要定义分块的语法。 它将包含需要遵循的规则。
第2步 - 在这一步中，需要创建一个块解析器。 它会解析语法并给出结果。
第3步 - 在最后一步中，输出以树格式生成。

按照以下步骤导入必要的NLTK包 -

import nltk

现在，我们需要定义这个句子。 这里，DT表示行列式，VBP表示动词，JJ表示形容词，IN表示介词，NN表示名词。

sentence=[("a","DT"),("clever","JJ"),("fox","NN"),("was","VBP"),
("jumping","VBP"),("over","IN"),("the","DT"),("wall","NN")]

现在，我们需要给出语法。 在这里以正则表达式的形式给出语法。

grammar = "NP:{<DT>?<JJ>*<NN>}"

我们需要定义一个解析器来解析语法。

parser_chunking = nltk.RegexpParser(grammar)

解析器解析该句子如下 -

parser_chunking.parse(sentence)

接下来，需要获得输出。 输出在名为output_chunk的变量中生成。

Output_chunk = parser_chunking.parse(sentence)

执行以下代码后，以树的形式绘制输出结果。

output.draw()

执行上面代码，得到以下结果 -

词袋(BOW)模型

词袋 - 英文为:Bag of Word(BoW) ，它是自然语言处理中的一个模型，基本上用于从文本中提取特征，以便文本可用于建模，以便在机器学习算法中使用。

现在问题出现了，为什么我们需要从文本中提取特征。 这是因为机器学习算法不能处理原始数据，他们需要数字数据，以便可以从中提取有意义的信息。 将文本数据转换为数字数据称为特征提取或特征编码。

它是怎么运行的
这是从文本中提取特征的非常简单的方法。 假设我们有一个文本文档，并且希望将其转换为数字数据或者说想从中提取特征，那么首先这个模型从文档中的所有单词中提取词汇。 然后通过使用文档术语矩阵，它将建立一个模型。通过这种方式，BoW仅将文件表示为一袋文字。 丢弃关于文档中单词的顺序或结构的任何信息。

文档术语矩阵的概念

BoW算法通过使用文档术语矩阵来建立模型。 顾名思义，文档术语矩阵就是文档中出现的各种字数的矩阵。 在这个矩阵的帮助下，文本文档可以表示为各种单词的加权组合。 通过设置阈值并选择更有意义的单词，我们可以构建文档中可用作特征向量的所有单词的直方图。 以下是了解文档术语矩阵概念的示例 -

示例

假设有以下两个句子 -

• 句子1 - 正在使用词袋模型。
• 句子2 - Bag of Words模型用于提取特征。

现在，通过考虑这两句子，有以下13个不同的单词 -

• we
• are
• using
• the
• bag
• of
• words
• model
• is
• used
• for
• extracting
• features

现在，我们需要使用每个句子中的单词计数为每个句子建立一个直方图 -

• 子句1 − [1,1,1,1,1,1,1,1,0,0,0,0,0]
• 子句2 − [0,0,0,1,1,1,1,1,1,1,1,1,1]

这样，就得到了已经提取的特征向量。每个特征向量都是13维的，因为这里有13个不同的单词。

统计概念

统计学的概念称为TermFrequency-Inverse Document Frequency(tf-idf)。 每个单词在文档中都很重要。 统计数据有助于我们理解每个词的重要性。

术语频率(tf)
这是衡量每个单词出现在文档中的频率。 它可以通过将每个词的计数除以给定文档中的词的总数来获得。

逆文档频率(idf)
这是衡量在给定的文档集中这个文档有多独特的一个单词。要计算idf和制定一个特征向量，我们需要减少像这样的常见词的权重，并权衡稀有词。

在NLTK中建立一个词袋模型

在本节中，我们将使用CountVectorizer从这些句子中创建矢量来定义字符串集合。

导入必要的软件包 -

from sklearn.feature_extraction.text import CountVectorizer

现在定义一组句子。

Sentences = ['We are using the Bag of Word model', 'Bag of Word model is
used for extracting the features.']

vectorizer_count = CountVectorizer()

features_text = vectorizer.fit_transform(Sentences).todense()

print(vectorizer.vocabulary_)

上述程序生成如下所示的输出。它表明在上述两句话中有13个不同的单词 -

{'we': 11, 'are': 0, 'using': 10, 'the': 8, 'bag': 1, 'of': 7,
'word': 12, 'model': 6, 'is': 5, 'used': 9, 'for': 4, 'extracting': 2, 'features': 3}

这些是可以用于机器学习的特征向量(文本到数字形式)。

解决问题

在本节中，我们将解决一些相关问题。

类别预测

在一组文件中，不仅单词而且单词的类别也很重要; 在哪个类别的文本中特定的词落入。 例如，想要预测给定的句子是否属于电子邮件，新闻，体育，计算机等类别。在下面的示例中，我们将使用tf-idf来制定特征向量来查找文档的类别。使用sklearn的20个新闻组数据集中的数据。

导入必要的软件包 -

from sklearn.datasets import fetch_20newsgroups
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.feature_extraction.text import CountVectorizer

定义分类图。使用五个不同的类别，分别是宗教，汽车，体育，电子和空间。

category_map = {'talk.religion.misc':'Religion','rec.autos''Autos',
'rec.sport.hockey':'Hockey','sci.electronics':'Electronics', 'sci.space': 'Space'}

创建训练集 -

training_data = fetch_20newsgroups(subset = 'train',
categories = category_map.keys(), shuffle = True, random_state = 5)

构建一个向量计数器并提取术语计数 -

vectorizer_count = CountVectorizer()
train_tc = vectorizer_count.fit_transform(training_data.data)
print("\nDimensions of training data:", train_tc.shape)

tf-idf转换器的创建过程如下 -

tfidf = TfidfTransformer()
train_tfidf = tfidf.fit_transform(train_tc)

现在，定义测试数据 -

input_data = [
'Discovery was a space shuttle',
'Hindu, Christian, Sikh all are religions',
'We must have to drive safely',
'Puck is a disk made of rubber',
'Television, Microwave, Refrigrated all uses electricity'
]

以上数据将用于训练一个Multinomial朴素贝叶斯分类器 -

classifier = MultinomialNB().fit(train_tfidf, training_data.target)

使用计数向量化器转换输入数据 -

input_tc = vectorizer_count.transform(input_data)

现在，将使用tfidf转换器来转换矢量化数据 -

input_tfidf = tfidf.transform(input_tc)

执行上面代码，将预测输出类别 -

predictions = classifier.predict(input_tfidf)

输出结果如下 -

for sent, category in zip(input_data, predictions):
print('\nInput Data:', sent, '\n Category:', \
category_map[training_data.target_names[category]])

类别预测器生成以下输出 -

Dimensions of training data: (2755, 39297)

Input Data: Discovery was a space shuttle
Category: Space

Input Data: Hindu, Christian, Sikh all are religions
Category: Religion

Input Data: We must have to drive safely
Category: Autos

Input Data: Puck is a disk made of rubber
Category: Hockey

Input Data: Television, Microwave, Refrigrated all uses electricity
Category: Electronics

性别发现器

在这个问题陈述中，将通过提供名字来训练分类器以找到性别(男性或女性)。 我们需要使用启发式构造特征向量并训练分类器。这里使用scikit-learn软件包中的标签数据。 以下是构建性别查找器的Python代码 -

导入必要的软件包 -

import random

from nltk import NaiveBayesClassifier
from nltk.classify import accuracy as nltk_accuracy
from nltk.corpus import names

现在需要从输入字中提取最后的N个字母。 这些字母将作为功能 -

def extract_features(word, N = 2):
last_n_letters = word[-N:]
return {'feature': last_n_letters.lower()}

if __name__=='__main__':

使用NLTK中提供的标签名称(男性和女性)创建培训数据 -

male_list = [(name, 'male') for name in names.words('male.txt')]
female_list = [(name, 'female') for name in names.words('female.txt')]
data = (male_list + female_list)

random.seed(5)
random.shuffle(data)

现在，测试数据将被创建如下 -

namesInput = ['Rajesh', 'Gaurav', 'Swati', 'Shubha']

使用以下代码定义用于列车和测试的样本数 -

train_sample = int(0.8 * len(data))

现在，需要迭代不同的长度，以便可以比较精度 -

for i in range(1, 6):
print('\nNumber of end letters:', i)
features = [(extract_features(n, i), gender) for (n, gender) in data]
train_data, test_data = features[:train_sample],
features[train_sample:]
classifier = NaiveBayesClassifier.train(train_data)

分类器的准确度可以计算如下 -

accuracy_classifier = round(100 * nltk_accuracy(classifier, test_data), 2)
print('Accuracy = ' + str(accuracy_classifier) + '%')

现在，可以预测输出结果 -

for name in namesInput:
print(name, '==>', classifier.classify(extract_features(name, i))

上述程序将生成以下输出 -

Number of end letters: 1
Accuracy = 74.7%
Rajesh -> female
Gaurav -> male
Swati -> female
Shubha -> female

Number of end letters: 2
Accuracy = 78.79%
Rajesh -> male
Gaurav -> male
Swati -> female
Shubha -> female

Number of end letters: 3
Accuracy = 77.22%
Rajesh -> male
Gaurav -> female
Swati -> female
Shubha -> female

Number of end letters: 4
Accuracy = 69.98%
Rajesh -> female
Gaurav -> female
Swati -> female
Shubha -> female

Number of end letters: 5
Accuracy = 64.63%
Rajesh -> female
Gaurav -> female
Swati -> female
Shubha -> female

在上面的输出中可以看到，结束字母的最大数量的准确性是两个，并且随着结束字母数量的增加而减少。

主题建模:识别文本数据中的模式

我们知道，一般而言，文档被分组为主题。 有时需要确定文本中与特定主题相对应的模式。 这样做的技术称为主题建模。 换句话说，可以说主题建模是一种揭示给定文档集合中抽象主题或隐藏结构的技术。

可以在以下场景中使用主题建模技术 -

文本分类
在主题建模的帮助下，分类可以得到改进，因为它将相似的单词分组在一起，而不是分别将每个单词用作特征。

推荐系统
在主题建模的帮助下，可以使用相似性度量来构建推荐系统。

主题建模算法

主题建模可以通过使用算法来实现。 算法如下 -

潜在狄利克雷分配(LDA)
该算法是主题建模中最流行的算法。 它使用概率图形模型来实现主题建模。 我们需要在Python中导入gensim包以使用LDA slgorithm。

潜在语义分析(LDA)或潜在语义索引(LSI)
该算法基于线性代数。 基本上它在文档术语矩阵上使用SVD(奇异值分解)的概念。

非负矩阵分解(NMF)
它也基于线性代数。

上述所有用于话题建模的算法都将主题数量作为参数，将文档 - 词汇矩阵作为输入，将WTM(词主题矩阵)和TDM(主题文档矩阵)作为输出。

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

分析时间序列数据 - 人工智能（Python）教程™

预测给定输入序列中的下一个是机器学习中的另一个重要概念。 本章为您提供有关分析时间序列数据的详细说明。

时间序列数据介绍

时间序列数据表示处于一系列特定时间间隔的数据。 如果我们想在机器学习中构建序列预测，那么必须处理连续的数据和时间。 系列数据是连续数据的摘要。 数据排序是顺序数据的一个重要特征。

序列分析或时间序列分析的基本概念

序列分析或时间序列分析是基于先前观察到的预测给定输入序列中的下一个。 预测可以是任何可能接下来的事情:符号，数字，次日天气，下一个演讲等。序列分析在诸如股票市场分析，天气预报和产品推荐等应用中非常有用。

实例

考虑下面的例子来理解序列预测。 这里A，B，C，D是给定值，并且必须使用序列预测模型预测值E。

安装有用的包

对于使用Python进行时间序列数据分析，我们需要安装以下软件包 -

Pandas

Pandas是一个开源的BSD许可库，它为Python提供了高性能，简便的数据结构使用和数据分析工具。

有关Pandas教程，请访问以下网址:https://www.yiibai.com/pandas/

使用以下命令安装Pandas -

pip install pandas

如果您使用的是Anaconda并希望使用conda软件包管理器进行安装，那么可以使用以下命令 -

conda install -c anaconda pandas

hmmlearn

它是一个开源BSD许可的库，它由简单的算法和模型组成，用于学习Python中的隐马尔可夫模型(HMM)。 使用以下命令安装它 -

pip install hmmlearn

如果您使用的是Anaconda并希望使用conda软件包管理器进行安装，那么可以使用以下命令 -

conda install -c anaconda hmmlearn

PyStruct

它是一个结构化的学习和预测库。 在PyStruct中实现的学习算法具有诸如条件随机场(CRF)，最大值 - 马尔科夫随机网络(M3N)或结构支持向量机等名称。使用以下命令来安装它 -

pip install pystruct

CVXOPT

它用于基于Python编程语言的凸优化。 它也是一个免费的软件包。 使用以下命令来安装它 -

pip install cvxopt

如果您使用的是Anaconda并希望使用conda软件包管理器进行安装，那么可以使用以下命令 -

conda install -c anaconda cvdoxt

Pandas:从时间序列数据中处理，分割和提取统计信息

如果必须使用时间序列数据，Pandas是一个非常有用的工具。 在Pandas的帮助下，可以执行以下操作 -

• 使用pd.date_range包创建一系列日期
• 通过使用pd.Series包对带有日期数据进行索引
• 使用ts.resample包执行重新采样
• 改变频率

示例

以下示例显示使用Pandas处理和分割时间序列数据。 请注意，这里使用月度北极涛动数据，可以从monthly.ao.index.b50.current.ascii下载并可以转换为文本格式。

处理时间序列数据

要处理时间序列数据，您必须执行以下步骤 -

第1步 ，导入以下软件包 -

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

接下来，定义一个函数，它将从输入文件中读取数据，如以下代码所示 -

def read_data(input_file):
input_data = np.loadtxt(input_file, delimiter = None)

现在，将这些数据转换为时间序列。 为此，请创建时间序列的日期范围。 在这个例子中，我们保留一个月的数据频率。 文件中是存储从1950年1月开始的数据。

dates = pd.date_range('1950-01', periods = input_data.shape[0], freq = 'M')

在这一步中，在Pandas Series的帮助下创建时间序列数据，如下所示 -

output = pd.Series(input_data[:, index], index = dates)
return output

if __name__=='__main__':

如下所示，指定输入文件的路径 -

input_file = "/Users/admin/AO.txt"

现在，将列转换为时间序列格式，如下所示 -

timeseries = read_data(input_file)

最后，使用显示的命令绘制并可视化数据 -

plt.figure()
timeseries.plot()
plt.show()

观察如下图所示 -

切片时间序列数据
切片涉及仅检索时间序列数据的一部分。 作为示例的一部分，我们仅在1980年到1990年间对数据进行分割。请注意以下执行此任务的代码 -

timeseries['1980':'1990'].plot()
<matplotlib.axes._subplots.AxesSubplot at 0xa0e4b00>

plt.show()

当您运行切片时间序列数据的代码时，可以观察下图所示的图形 -

从时间序列数据中提取统计信息

如果需要得出一些重要结论，需要从一个给定的数据中提取一些统计数据。 平均值，方差，相关性，最大值和最小值是这些统计中的一部分。 如果您想从给定的时间序列数据中提取此类统计信息，则可以使用以下代码 -

平均值

可以使用mean()函数来查找平均值，如下所示 -

timeseries.mean()

例子代码的输出是 -

-0.11143128165238671

最大值

可以使用max()函数来查找最大值，如下所示 -

timeseries.max()

那么在讨论的例子中观察的输出是 -

3.4952999999999999

最小值

可以使用min()函数来查找最小值，如下所示 -

timeseries.min()

那么在讨论的例子中观察的输出是 -

-4.2656999999999998

一次性获得所有

如果您想一次计算所有统计数据，则可以使用describe()函数，如下所示 -

timeseries.describe()

那么观察上面例子的输出是 -

count 817.000000
mean -0.111431
std 1.003151
min -4.265700
25% -0.649430
50% -0.042744
75% 0.475720
max 3.495300
dtype: float64

重新取样

可以将数据重新采样到不同的时间频率。 执行重新采样的两个参数是 -

• 时间段
• 方法

使用mean()重新采样

以下代码使用mean()方法重新采样数据，这是默认方法 -

timeseries_mm = timeseries.resample("A").mean()
timeseries_mm.plot(style = 'g--')
plt.show()

然后，可以观察下面使用mean()重采样输出的图形 -

使用median()重新采样

使用以下代码使用median()方法重新采样数据 -

timeseries_mm = timeseries.resample("A").median()
timeseries_mm.plot()
plt.show()

然后，观察下面的图形是使用median()重新采样的输出 -

滚动平均值

使用下面的代码来计算滚动(移动)的平均值 -

timeseries.rolling(window = 12, center = False).mean().plot(style = '-g')
plt.show()

然后，观察滚动(移动)平均值的输出图表 -

隐马尔可夫模型(HMM)分析顺序数据

HMM是一种统计模型，广泛用于时间序列股市分析，健康检查和语音识别等具有延续性和可扩展性的数据。 本节详细介绍使用隐马尔可夫模型(HMM)分析顺序数据。

隐马尔可夫模型(HMM)

HMM是一个基于马尔可夫链概念的随机模型，它基于未来统计量的概率仅取决于当前过程状态而非其之前的任何状态的假设。 例如，当扔硬币时，不能说第五次抛掷的结果是正面。 这是因为硬币没有任何记忆，下一个结果不依赖于以前的结果。

在数学上，HMM由以下变量组成 -

状态(S)
它是HMM中存在的一组隐藏或潜在状态。 它由S表示。

输出符号(O)
它是HMM中存在的一组可能的输出符号。 它由O表示。

状态转移概率矩阵(A)
这是从一个状态过渡到其他状态的可能性。 它由A表示。

观测发射概率矩阵(B)
它是在特定状态下发射/观测符号的概率。 它由B表示。

先验概率矩阵(Π)
这是从系统的各种状态开始处于特定状态的概率。 它由Π表示。
因此，HMM可以被定义为λ=(S，O，A，B，π)，
其中，

• S = {s1,s2,…,sN}是一组N个可能的状态，
• O = {o1，o2，…，oM}是一组M个可能的观察符号，
• A是N×N状态转移概率矩阵(TPM)，
• B是N
  

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

语音识别 - 人工智能（Python）教程™

在本章中，我们将学习使用AI和Python进行语音识别。
言语是成人人际沟通的最基本手段。 语音处理的基本目标是提供人与机器之间的交互。
语音处理系统主要有三项任务 -

• 首先，语音识别允许机器捕捉我们所说的单词，短语和句子
• 其次，自然语言处理使机器能够理解我们所说的话
• 第三，语音合成允许机器说话。

本章重点讲述语音识别，理解人类说话的过程。 请记住，在麦克风的帮助下捕捉语音信号，然后系统才能理解它。

构建语音识别器

语音识别或自动语音识别(ASR)是AI机器人等AI项目的关注焦点。 没有ASR，就不可能想象一个认知机器人与人进行交互。 但是，构建语音识别器并不容易。

开发语音识别系统的困难
开发高质量的语音识别系统确实是一个难题。 语音识别技术的困难可以广泛地表征为如下所讨论的许多维度 -

• 词汇大小 - 词汇大小影响开发ASR的难易程度。考虑以下词汇量以便更好地理解。
  • 例如，在一个语音菜单系统中，一个小词汇由2到100个单词组成
  • 例如，在数据库检索任务中，中等大小的词汇包含几个100到1000个单词
  • 一个大的词汇由几万个单词组成，如在一般的听写任务中。
• 信道特性 - 信道质量也是一个重要的维度。 例如，人类语音包含全频率范围的高带宽，而电话语音包含频率范围有限的低带宽。 请注意，后者更难。
• 说话模式 - 轻松开发ASR还取决于说话模式，即语音是处于孤立词模式还是连接词模式，还是处于连续语音模式。 请注意，连续说话很难辨认。
• 口语风格 - 阅读说话可以采用正式风格，也可以采用自发风格和对话风格。 后者更难以识别。
• 扬声器依赖性 - 语音可以依赖扬声器，扬声器自适应或扬声器独立。 独立发言人是最难建立的。
• 噪音类型 - 噪音是开发ASR时需要考虑的另一个因素。 信噪比可以在各种范围内，这取决于观察较少的声学环境与较多的背景噪声 -
  • 如果信噪比大于30dB，则认为是高范围
  • 如果信噪比在30dB到10db之间，则认为是中等信噪比
  • 如果信噪比小于10dB，则认为是低范围
• 麦克风特性 - 麦克风的质量可能很好，平均水平或低于平均水平。 此外，嘴和微型电话之间的距离可能会有所不同。 识别系统也应考虑这些因素。

尽管存在这些困难，研究人员在语音的各个方面做了很多工作，例如理解语音信号，说话人以及识别口音。

所以，需要按照以下步骤构建语音识别器 -

可视化音频信号 - 从文件读取并进行处理

这是构建语音识别系统的第一步，因为它可以帮助您理解音频信号的结构。 处理音频信号可遵循的一些常见步骤如下所示 -

记录
当必须从文件中读取音频信号时，首先使用麦克风录制。

采样
用麦克风录音时，信号以数字形式存储。 但为了解决这个问题，机器需要使用离散数字形式。 因此，我们应该以某个频率进行采样，并将信号转换为离散数字形式。 选择高频采样意味着当人类听到信号时，他们会感觉它是一个连续的音频信号。

示例

以下示例显示了使用Python存储在文件中的逐步分析音频信号的方法。 这个音频信号的频率是44,100HZ。

下面导入必要的软件包 -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

现在，读取存储的音频文件。 它会返回两个值:采样频率和音频信号。 提供存储音频文件的路径，如下所示 -

frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")

使用显示的命令显示音频信号的采样频率，信号的数据类型及其持续时间等参数 -

print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] /
float(frequency_sampling), 2), 'seconds')

这一步涉及如下所示对信号进行标准化 -

audio_signal = audio_signal / np.power(2, 15)

在这一步中，从这个信号中提取出前100个值进行可视化。 为此目的使用以下命令 -

audio_signal = audio_signal [:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(frequency_sampling)

现在，使用下面给出的命令可视化信号 -

plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time (milliseconds)')
plt.ylabel('Amplitude')
plt.title('Input audio signal')
plt.show()

下面输出图形是上述音频信号提取的数据，如图所示 -

Signal shape: (132300,)
Signal Datatype: int16
Signal duration: 3.0 seconds

表征音频信号:转换到频域

表征音频信号涉及将时域信号转换为频域，并通过以下方式理解其频率分量。 这是一个重要的步骤，因为它提供了关于信号的大量信息。 可以使用像傅立叶变换这样的数学工具来执行此转换。

示例

以下示例将逐步说明如何使用存储在文件中的Python来表征信号。 请注意，这里使用傅里叶变换数学工具将其转换为频域。

导入必要的软件包，如下所示 -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

现在，读取存储的音频文件。 它会返回两个值:采样频率和音频信号。 提供存储音频文件的路径，如命令所示 -

frequency_sampling, audio_signal = wavfile.read("/Users/admin/sample.wav")

在这一步中，将使用下面给出的命令显示音频信号的采样频率，信号的数据类型和持续时间等参数 -

print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] /
float(frequency_sampling), 2), 'seconds')

在这一步中，我们需要对信号进行标准化，如下面的命令所示 -

audio_signal = audio_signal / np.power(2, 15)

这一步涉及提取信号的长度和半长。使用以下命令 -

length_signal = len(audio_signal)
half_length = np.ceil((length_signal + 1) / 2.0).astype(np.int)

现在，需要应用数学工具来转换到频域。 这里使用傅里叶变换。

signal_frequency = np.fft.fft(audio_signal)

现在，进行频域信号的归一化并将其平方 -

signal_frequency = abs(signal_frequency[0:half_length]) / length_signal
signal_frequency **= 2

接下来，提取频率变换信号的长度和一半长度 -

len_fts = len(signal_frequency)

请注意，傅里叶变换信号必须针对奇偶情况进行调整。

if length_signal % 2:
signal_frequency[1:len_fts] *= 2
else:
signal_frequency[1:len_fts-1] *= 2

现在，以分贝(dB)为单位提取功率 -

signal_power = 10 * np.log10(signal_frequency)

调整X轴的以kHz为单位的频率 -

x_axis = np.arange(0, len_half, 1) * (frequency_sampling / length_signal) / 1000.0

现在，将信号的特征可视化如下 -

plt.figure()
plt.plot(x_axis, signal_power, color='black')
plt.xlabel('Frequency (kHz)')
plt.ylabel('Signal power (dB)')
plt.show()

可以观察上面代码的输出图形，如下图所示 -

生成单调音频信号

到目前为止你所看到的两个步骤对于了解信号很重要。 现在，如果要使用某些预定义参数生成音频信号，此步骤将很有用。 请注意，此步骤会将音频信号保存在输出文件中。

示例

在下面的例子中，我们将使用Python生成一个单调信号，它将被存储在一个文件中。需要采取以下步骤 -

导入必要的软件包 -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io.wavfile import write

指定输出保存的文件 -

output_file = 'audio_signal_generated.wav'

现在，指定选择的参数，如图所示 -

duration = 4 # in seconds
frequency_sampling = 44100 # in Hz
frequency_tone = 784
min_val = -4 * np.pi
max_val = 4 * np.pi

在这一步中，我们可以生成音频信号，如下代码所示 -

t = np.linspace(min_val, max_val, duration * frequency_sampling)
audio_signal = np.sin(2 * np.pi * tone_freq * t)

现在，将音频文件保存在输出文件中 -

write(output_file, frequency_sampling, signal_scaled)

如图所示，提取图形的前100个值 -

audio_signal = audio_signal[:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(sampling_freq)

现在，将生成的音频信号可视化如下 -

plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time in milliseconds')
plt.ylabel('Amplitude')
plt.title('Generated audio signal')
plt.show()

可以观察这里给出的图形 -

语音特征提取

这是构建语音识别器的最重要步骤，因为在将语音信号转换为频域后，我们必须将其转换为可用的特征向量形式。 可以为此使用不同的特征提取技术，如MFCC，PLP，PLP-RASTA等。

示例

在以下示例中，我们将使用MFCC技术逐步使用Python从信号中提取特征。

导入必要的软件包，如下所示 -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from python_speech_features import mfcc, logfbank

现在，读取存储的音频文件。 它会返回两个值 - 采样频率和音频信号。 提供存储音频文件的路径。

frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")

请注意，在此首先抽取15000个样本进行分析。

audio_signal = audio_signal[:15000]

使用MFCC技术并执行以下命令来提取MFCC特征 -

features_mfcc = mfcc(audio_signal, frequency_sampling)

现在，打印MFCC参数，如下所示 -

print('\nMFCC:\nNumber of windows =', features_mfcc.shape[0])
print('Length of each feature =', features_mfcc.shape[1])

使用下面给出的命令绘制并可视化MFCC特征 -

features_mfcc = features_mfcc.T
plt.matshow(features_mfcc)
plt.title('MFCC')

在这一步中，我们使用如下滤器组特征，提取过滤器组特征 -

filterbank_features = logfbank(audio_signal, frequency_sampling)

现在，打印过滤器组参数。

print('\nFilter bank:\nNumber of windows =', filterbank_features.shape[0])
print('Length of each feature =', filterbank_features.shape[1])

绘制并可视化过滤器组特征。

filterbank_features = filterbank_features.T
plt.matshow(filterbank_features)
plt.title('Filter bank')
plt.show()

根据上述步骤，您可以观察到以下输出:图1为MFCC，图2为过滤器组。

口语词的识别

语音识别意味着当人们说话时，机器就会理解它。 这里使用Python中的Google Speech API来实现它。 需要为此安装以下软件包 -

• Pyaudio - 它可以通过使用pip安装Pyaudio命令进行安装。
• SpeechRecognition - 这个软件包可以通过使用pip install SpeechRecognition进行安装。
• Google-Speech-API - 可以使用命令pip install google-api-python-client进行安装。

实例

观察下面的例子来理解口语的识别。如下所示导入必要的软件包 -

import speech_recognition as sr

创建一个对象，如下所示 -

recording = sr.Recognizer()

现在，Microphone()模块将把语音作为输入 -

with sr.Microphone() as source: recording.adjust_for_ambient_noise(source)
print("Please Say something:")
audio = recording.listen(source)

现在谷歌API会识别语音并提供输出。

try:
print("You said: \n" + recording.recognize_google(audio))
except Exception as e:
print(e)

可以看到下面的输出 -

Please Say Something:
You said:

例如，如果您说yiibai.com，那么系统会如下正确识别它 -

yiibai.com

易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。

启发式搜索 - 人工智能（Python）教程™

启发式搜索在人工智能中起着关键作用。 在本章中，我们来详细地了解它。

AI中启发式搜索的概念

启发式是一条经验法则，它将我们引向可能的解决方案。 人工智能中的大多数问题具有指数性，并且有许多可能的解决方案。并不确切知道哪些解决方案是正确的，检查所有解决方案会非常昂贵。

因此，启发式的使用缩小了搜索解决方案的范围并消除了错误的选项。 启发式引导搜索空间中的搜索的方法称为启发式搜索。 启发式技术非常有用，因为使用它们时可以提高搜索效率。

不知情和知情搜索之间的区别

有两种控制策略或搜索技术:不知情和知情。这里给出的详细解释如下 -

不知情的搜索
它也被称为盲搜索或盲控制策略。 它的命名是因为只有关于问题定义的信息，并且没有关于状态的其他额外信息。 这种搜索技术将搜索整个状态空间以获得解决方案。 广度优先搜索(BFS)和深度优先搜索(DFS)是非信息搜索的示例。

知情搜索
它也被称为启发式搜索或启发式控制策略。 它的名字是因为有一些额外的状态信息。 这些额外的信息对计算子节点之间的偏好以便探索和扩展很有用。 将会有与每个节点相关的启发式功能。 Best First Search(BFS)，A *，Mean和Analysis是知情搜索的例子。

约束满足问题(CSP)
约束意味着限制或限制。 在人工智能中，约束满足问题是一些约束条件下必须解决的问题。 重点必须是在解决这些问题时不要违反约束条件。 最后，当我们达成最终解决方案时，CSP必须遵守限制。

约束满足解决的现实世界问题

前面的部分涉及创建约束满足问题。 现在将它应用于现实世界的问题。 通过约束满足解决的现实世界问题的一些例子如下 -

解决代数关系

在约束满足问题的帮助下，可以求解代数关系。 在这个例子中，我们将尝试解决一个简单的代数关系a * 2 = b。 它会在我们定义的范围内返回a和b的值。

完成此Python程序后，您将能够理解解决约束满足问题的基础知识。

请注意，在编写程序之前，需要安装名为python-constraint的Python包。使用以下命令安装它 -

pip install python-constraint

以下步骤向您展示了一个使用约束满足来解决代数关系的Python程序。

使用以下命令导入约束包 -

from constraint import *

现在，创建一个名为problem()的模块对象，如下所示 -

problem = Problem()

现在，定义变量。请注意，这里有两个变量a和b，并且将定义10为它们的范围，这意味着在前10个数字范围内得到解决。

problem.addVariable('a', range(10))
problem.addVariable('b', range(10))

接下来，定义应用于这个问题的特定约束。 请注意，这里使用约束a * 2 = b。

problem.addConstraint(lambda a, b: a * 2 == b)

现在，使用以下命令创建getSolution()模块的对象 -

solutions = problem.getSolutions()

最后，使用以下命令打印输出 -

print (solutions)

可以观察上述程序的输出如下 -

[{'a': 4, 'b': 8}, {'a': 3, 'b': 6}, {'a': 2, 'b': 4}, {'a': 1, 'b': 2}, {'a': 0, 'b': 0}]

魔幻正方形
一个神奇的正方形是一个正方形网格中不同数字(通常是整数)的排列，其中每行和每列中的数字以及对角线上的数字加起来就是所谓的“魔术常数”。

以下是用于生成幻方的简单Python代码的逐步执行 -

定义一个名为magic_square的函数，如下所示 -

def magic_square(matrix_ms):
iSize = len(matrix_ms[0])
sum_list = []

以下代码显示了垂直方块的代码 -

for col in range(iSize):
sum_list.append(sum(row[col] for row in matrix_ms))

以下代码显示了水平方块的代码 -

sum_list.extend([sum (lines) for lines in matrix_ms])

水平方块的代码实现 -

dlResult = 0
for i in range(0,iSize):
dlResult +=matrix_ms[i][i]
sum_list.append(dlResult)
drResult = 0
for i in range(iSize-1,-1,-1):
drResult +=matrix_ms[i][i]
sum_list.append(drResult)

if len(set(sum_list))>1:
return False
return True

现在，给出矩阵的值并查看输出结果 -

print(magic_square([[1,2,3], [4,5,6], [7,8,9]]))

可以观察到由于总和未达到相同数字，输出将为False。

print(magic_square([[3,9,2], [3,5,7], [9,1,6]]))

可以观察到输出将为True，因为总和是相同的数字，即15。