第1章 Python机器学习的生态系统

太过爱你忘了你带给我的痛 2022-06-03 06:48 128阅读 0赞

##     ##

[Python机器学习实践指南][Python]

机器学习正在迅速改变我们的世界。作为人工智能的核心，我们几乎每天都会读到机器学习如何改变日常的生活。一些人认为它会带领我们进入一个风格奇异的高科技乌托邦；而另一些人认为我们正迈向一个高科技天启时代，将与窃取我们工作机会的机器人和无人机敢死队进行持久的战争。不过，虽然权威专家们可能会喜欢讨论这些夸张的未来，但更为平凡的现实是，机器学习正在快速成为我们日常生活的固定装备。随着我们微小但循序渐进地改进自身与计算机以及周围世界之间的互动，机器学习正在悄悄地改善着我们的生活。

如果你在Amazon.com这样的在线零售商店购物，使用Spotify或Netflix这样的流媒体音乐或电影服务，甚至只是执行一次Google搜索，你就已经触碰到了机器学习的应用。使用这些服务的用户会产生数据，这些数据会被收集、汇总并送入模型，而模型最终会为每个用户创建个性化的体验来完善服务。

想要深入到机器学习应用的开发中，现在就是一个理想的时机。你会发现，Python是开发这些应用的理想选择。Python拥有一个深度的、活跃的开发者社区，许多开发者也来自科学家的社区。这为Python提供了一组丰富的科学计算库。在本书中，我们将讨论并使用这些来自Python科学栈的库。

在接下来的章节中，我们将一步步学习如何建立各种不同的机器学习应用。但是，在真正开始之前，我们将使用本章剩下的篇幅讨论这些关键库的特性，以及如何准备能充分利用它们的环境。

我们将在本章中介绍以下主题。

*  数据科学/机器学习的工作流程。
 *  工作流中每个阶段的库。
 *  设置你的环境。

## 1.1　数据科学/机器学习的工作流程 ##

打造机器学习的应用程序，与标准的工程范例在许多方面都是类似的，不过有一个非常重要的方法有所不同：需要将数据作为原材料来处理。数据项目成功与否，很大程度上依赖于你所获数据的质量，以及它是如何被处理的。由于数据的使用属于数据科学的领域，理解数据科学的工作流程对于我们也有所帮助：整个过程要按照图1-1中的顺序，完成六个步骤：获取，检查和探索，清理和准备，建模，评估和最后的部署。

在这个过程中，还经常需要绕回到之前的步骤，例如检查和准备数据，或者是评估和建模，但图1-1所示的内容可以描述该过程较高层次的抽象。

![1][]

图1-1

现在让我们详细讨论每一个步骤。

### 1.1.1　获取 ###

机器学习应用中的数据，可以来自不同的数据源，它可能是通过电子邮件发送的CSV文件，也可能是从服务器中拉取出来的日志，或者它可能需要构建自己的Web爬虫。数据也可能存在不同的格式。在大多数情况下，它是基于文本的数据，但稍后将看到，构建处理图像甚至视频文件的机器学习应用，也是很容易的。不管是什么格式，一旦锁定了某种数据，那么了解该数据中有什么以及没有什么，就变得非常重要了。

### 1.1.2　检查和探索 ###

一旦获得了数据，下一步就是检查和探索它们。在这个阶段中，主要的目标是合理地检查数据，而实现这一点的最好办法是发现不可能或几乎不可能的事情。举个例子，如果数据具有唯一的标识符，检查是否真的只有一个；如果数据是基于价格的，检查是否总为正数；无论数据是何种类型，检查最极端的情况。它们是否有意义？一个良好的实践是在数据上运行一些简单的统计测试，并将数据可视化。此外，可能还有一些数据是缺失的或不完整的。在本阶段注意到这些是很关键的，因为需要在稍后的清洗和准备阶段中处理它。只有进入模型的数据质量好了，模型的质量才能有保障，所以将这一步做对是非常关键的。

### 1.1.3　清理和准备 ###

当所有的数据准备就绪，下一步是将它转化为适合于模型使用的格式。这个阶段包括若干过程，例如过滤、聚集、输入和转化。所需的操作类型将很大程度上取决于数据的类型，以及所使用的库和算法的类型。例如，对于基于自然语言的文本，其所需的转换和时间序列数据所需的转换是非常不同的。全书中，我们将会看到一些转换的的例子。

### 1.1.4　建模 ###

一旦数据的准备完成后，下一阶段就是建模了。在这个阶段中，我们将选择适当的算法，并在数据上训练出一个模型。在这个阶段，有许多最佳实践可以遵循，我们将详细讨论它们，但是基本的步骤包括将数据分割为训练、测试和验证的集合。这种数据的分割可能看上去不合逻辑——尤其是在更多的数据通常会产生更好的模型这种情况下——但正如我们将看到的，这样做可以让我们获得更好的反馈，理解该模型在现实世界中会表现得如何，并避免建模的大忌：过拟合。

### 1.1.5　评估 ###

一旦模型构建完成并开始进行预测，下一步是了解模型做得有多好。这是评估阶段试图回答的问题。有很多的方式来衡量模型的表现，同样，这在很大程度上依赖于所用数据和模型的类型，不过就整体而言，我们试图回答这样的问题：模型的预测和实际值到底有多接近。有一堆听上去令人混淆的名词，例如根均方误差、欧几里德距离，以及F1得分，但最终，它们还是实际值与预估值之间的距离量度。

### 1.1.6　部署 ###

一旦模型的表现令人满意，那么下一个步骤就是部署了。根据具体的使用情况，这个阶段可能有不同的形式，但常见的场景包括将其作为另一个大型应用程序中的某个功能特性，一个定制的Web应用程序，甚至只是一个简单的cron作业。

## 1.2　Python库和功能 ##

现在，我们已经对数据科学工作流的每一步有了初步的理解，下面来看看在每一步中，存在哪些有用的Python库和功能可供选择。

### 1.2.1　获取 ###

访问数据常见的方式之一是通过REST风格的API接口，需要知道的库是Python Request库（`http://www.python-requests.org/en/latest/）`。它被称为给人类使用的HTTP，为API的交互提供了一个整洁和简单的方式。

让我们来看一个使用Requests进行交互的例子，它从GitHub的API中拉取数据。在这里，我们将对该API进行调用，并请求某个用户的starred库列表。

import requests 
    r = requests.get(r"https://api.github.com/users/acombs/starred") 
    r.json()

这个请求将以JSON文档的形式，返回用户已经标记为starred的所有存储库以及它们的属性。图1-2是上述调用后输出结果的一个片段。

![Image 1][]

图1-2

`Requests`库有数量惊人的特性——这里无法全部涵盖，我建议你看看上面提供的链接所指向的文档。

### 1.2.2　检查 ###

由于数据检查是机器学习应用开发中关键的一步，我们现在来深入了解几个库，它们将在此项任务中很好地为我们服务。

#### 1．Jupyter记事本 ####

许多库有助于减轻数据检查过程的工作负荷。首先是带有IPython（`http://ipython.org/`）的Jupyter记事本。这是一个全面的、交互式的计算环境，对于数据探索是非常理想的选择。和大多数开发环境不同，Jupyter记事本是一个基于Web的前端（相对于IPython的内核而言），被分成单个的代码块或单元。根据需要，单元可以单独运行，也可以一次全部运行。这使得开发人员能够运行某个场景，看到输出结果，然后回到代码，做出调整，再看看所产生的变化——所有这些都无需离开记事本。图1-3是在Jupyter记事本中进行交互的样例。

![Image 1][]

图1-3

请注意，我们在这里做了一系列的事情，并不仅仅是和IPython的后端进行交互，而且也和终端shell进行了交互。这个特定的实例运行了Python 3.5的内核，但如果你愿意，也可以很容易地运行Python 2.X的内核。在这里，我们已经引入了Python `os`库，并进行了一次调用，找到当前的工作目录（单元`＃2`），你可以看到输入代码单元格下方的输出。然后，我们在单元\#3中使用`os`库改变了这个目录，但是在单元`＃4`中停止使用`os`库，而是开始使用基于Linux的命令。这是通过在单元前添加`！`符号来完成的。在单元`＃6`中可以看到，我们甚至能够将shell的输出保存到一个Python变量（`file_two`）。这是一个很棒的功能，使文件操作变成了一项简单的任务。

现在，让我们来看看使用该记事本所进行的一些简单的数据操作。这也是我们首次介绍另一个不可或缺的库：`pandas`。

#### 2．Pandas ####

Pandas是一个卓越的数据分析工具。根据Pandas的文档（`http://pandas.pydata.org/pandas-docs/version/0.17.1/`）：

它有一个更广泛的目标，就是成为任何语言中，最强大和灵活的开源数据分析/操作工具。

即使它还没有达到这个目标，也不会差得太远。现在让我们来看看。

import os    
    import pandas as pd    
    import requests    
    
    PATH = r'/Users/alexcombs/Desktop/iris/' 
    
    r= 
    requests.get('https://archive.ics.uci.edu/ml/machine-learning-databases/iri 
    s/iris.data')    
    
    with open(PATH + 'iris.data', 'w') as f:    
        f.write(r.text)    
    
    os.chdir(PATH)    
    
    df = pd.read_csv(PATH + 'iris.data', names=['sepal length', 'sepal width',    
    'petal length', 'petal width', 'class']) 
    
    df.head()

前面的代码和屏幕截图如图1-4所示，我们已经从`https://archive.ics.uci.edu/ml/datasets/Iris`下载了一个经典的机器学习数据集：`iris.data`，并将其写入`iris`目录。这实际上是一个CSV文件，通过Pandas，我们进行了一个调用并读取了该文件。我们还增加了列名，因为这个特定的文件缺一个标题行。如果该文件已经包含了一个标题行，Pandas会自动解析并反映这一点。和其他CSV库相比，Pandas将其变为一个简单的操作。

![Image 1][]

图1-4

解析文件只是该库的一个小功能。对适合于单台机器的数据集而言，Pandas是个终极的工具，这有点像Excel。就像流行的电子表格程序，操作的基本单位是表格形式的数据列和行。在Pandas的术语中，数据列称为系列（Series），而表格称为数据框（DateFrame）。

使用之前截屏中同样的`iris`数据框，让我们来看看几个常见的操作。

df['sepal length']

前面的代码生成图1-5的输出。

![Image 1][]

图1-5

第一个操作是通过列名，从数据框中选择某一列。执行数据切片的另一种方式是使用`.ix[row,column]`标注。让我们使用下面这个标注，来选择前两列和前四行。

df.ix[:3, :2]

前面的代码生成图1-6的输出。

使用`.ix标注`和Python列表切片的语法，我们能够选择该数据框中的一小片。现在，让我们更进一步，使用列表迭代器并只选择描述width的列。

df.ix[:3, [x for x in df.columns if 'width' in x]]

前面的代码生成图1-7所示的输出。

![Image 1][]

图1-6

![Image 1][]

图1-7

我们在这里所做的是创建一个列表，该列表是所有列的一个子集。前面的`df.columns`返回所有列的列表，而我们的迭代使用了一个条件查询，只选择标题中含有width字样的列。显然，在这种情况下，我们可以很容易地拼写出希望在列表中出现的列，但是这里展示了处理大规模数据集时该库所具有的能力。

我们已经看到了，如何基于其在数据框中的位置，来选择数据的分片，现在来看看另一种选择数据的方法。这次，我们将根据某些特定的条件，来选择数据的一个子集。我们首先列出所有可用的唯一类，然后选择其中之一。

df['class'].unique()

前面的代码生成图1-8的输出。

![1 1][]

图1-8

df[df['class']=='Iris-virginica']

在图1-9所示最右侧的一列中，我们可以看到数据框只包含`Iris-virginica`类的数据。事实上，选择之后图1-11中数据框的大小是50行，比图1-10中原来的150行要小一些。

df.count()    
    
    df[df['class']=='Iris-virginica'].count()

![1 2][]

图1-9

![1 3][]

图1-10

![Image 1][]

图1-11

我们还可以看到，在左侧的索引保留了原始行号。现在，可以将这些数据保存为一个新的数据框并重置索引，如下面的代码和截图1-12所示。

virginica = df[df['class']=='Iris-virginica'].reset_index(drop=True)
    virginica

![Image 1][]

图1-12

我们通过在某个列上放置条件来选择数据，现在来添加更多的条件。我们将回到初始的数据框，并使用两个条件选择数据。

df[(df['class']=='Iris-virginica')&(df['petal width']>2.2)]

上述代码生成图1-13的输出。

![Image 1][]

图1-13

数据框现在只包含来自`Iris-virginica`类、而且花瓣宽度大于2.2的数据。

现在，让我们使用Pandas，从虹膜数据集中获取一些快速的描述性统计数据。

df.describe()

上述代码生成图1-14的输出。

![Image 1][]

图1-14

随着数据框的`.describe()`方法被调用，我们收到了各相关列的描述性统计信息（请注意，类别信息被自动删除了，因为它在这里是不相关的）。如果想要更为详细的信息，还可以传入自定义的百分比。

df.describe(percentiles=[.20,.40,.80,.90,.95])

上述代码生成图1-15的输出。

![Image 1][]

图1-15

接下来，让我们检查这些特征之间是否有任何相关性。这可以通过在数据框上调用`.corr()`来完成。

df.corr()

上述代码生成图1-16的输出。

![Image 1][]

图1-16

默认地，系统返回每个行-列对中的Pearson相关系数。通过传递方法的参数，还可以切换到Kendall's tau或Spearman's秩相关系数（例如，`.corr(method="spearman")`或`.corr(method="kendall")`）。

#### 3．可视化 ####

目前为止，我们已经看到如何选择数据框的某一部分，并从数据中获取汇总的统计信息，现在让我们学习如何通过可视化的方式来观测数据。不过首先要回答的问题是，为什么要花费心思进行可视化的视察呢？来看一个例子就能明白这是为什么了。

表1-1展示了四组不同序列的`x值`和`y值`的汇总统计。

表1-1

<table style="display:inline-block; font-size:1rem; width:auto; max-width:100%; overflow:auto; border:1px solid rgb(246,246,246); color:rgb(51,51,51)"> 
 <thead style="background:rgb(246,246,246); color:rgb(0,0,0)"> 
  <tr> 
   <th style="padding:1rem 0.6rem; line-height:2rem"> <p style="line-height:2.27rem">序列的x和y</p> </th> 
   <th style="padding:1rem 0.6rem; line-height:2rem"> <p style="line-height:2.27rem">取值</p> </th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">x的平均值</p> </td> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">9</p> </td> 
  </tr> 
  <tr style="background-color:rgb(252,252,252)"> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">y的平均值</p> </td> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">7.5</p> </td> 
  </tr> 
  <tr> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">序列的x样本方差</p> </td> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">11</p> </td> 
  </tr> 
  <tr style="background-color:rgb(252,252,252)"> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">序列的y样本方差</p> </td> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">4.1</p> </td> 
  </tr> 
  <tr> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">x和y之间的相关性</p> </td> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">0.816</p> </td> 
  </tr> 
  <tr style="background-color:rgb(252,252,252)"> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">回归线</p> </td> 
   <td style="padding:1rem 0.6rem; line-height:2rem; min-width:10rem"> <p style="line-height:2.27rem">y=3.00+0.500x</p> </td> 
  </tr> 
 </tbody> 
</table>

基于四组序列拥有相同的汇总统计，我们可能会认为这些系列的可视化看上去也是相似。我们当然是错误的，非常错误。这四个序列是安斯库姆四重奏的一部分，他们被刻意制造出来用于说明可视化数据检查的重要性。每个序列绘制在图1-17中。

安斯库姆四重奏的网址：`https://en.wikipedia.org/wiki/Anscombe%27squartet`。

显然，经过可视化的观察之后，我们不再会认为这些数据集是相同的。所以，现在我们能理解可视化的重要性了，下面来看看一对用于可视化的、很有价值的Python库。

![Image 1][]

图1-17

#### Matplotlib库 ####

我们将要看到的第一个库是`matplotlib`。这是Python绘图库的鼻祖了。最初人们创建它是为了仿效MATLAB的绘图功能，现在它自己已经发展成为特性完善的库了，并拥有超多的功能。对于那些没有MATLAB背景的使用者，可能很难理解所有这些部件是如何共同协作来创造图表的。

我们将所有的部件拆分为多个逻辑模块，便于大家理解都发生了些什么。在深入理解`matplotlib`之前，让我们先设置Jupyter记事本，以便看清每个图像。要做到这一点，需要将以下几行添加到`import`声明中。

import matplotlib.pyplot as plt
    plt.style.use('ggplot')
    %matplotlib inline 
    import numpy as np

第一行引入了`matplotlib`，第二行将风格设置为近似`R`中的`ggplot`库（这需要matplotlib 1.41），第三行设置插图，让它们在记事本中可见，而最后一行引入了`numpy`。本章稍后，我们将在一些操作中使用`numpy`。

现在，让我们使用下面的代码，在鸢尾花Iris数据集上生成第一个图：

fig, ax = plt.subplots(figsize=(6,4)) 
    ax.hist(df['petal width'], color='black'); 
    ax.set_ylabel('Count', fontsize=12) 
    ax.set_xlabel('Width', fontsize=12) 
    plt.title('Iris Petal Width', fontsize=14, y=1.01)

前面的代码生成图1-18中的输出。

![Image 1][]

图1-18

即使是在这个简单的例子中，也发生了很多事情，让我们来逐行分析。第一行创建了宽度为6英寸和高度为4英寸的一个插图。然后，我们通过调用`.hist()`并传入数据，依照`iris`数据框绘制了花瓣宽度的直方图。这里还将直方图中柱子的颜色设置为`black`（黑色）。接下来的两行分别在*y*轴和*x*轴上放置标签，最后一行为全图设置了标题。其中使用*y*轴的参数调整了标题在*y*轴方向相对于图片顶部的位置，并微微增加了默认字体的大小。这使得我们从花瓣宽度的数据得到了一个很漂亮的直方图。现在，让我们进一步扩展，为`iris`数据集的每一列生成直方图。

fig, ax = plt.subplots(2,2, figsize=(6,4)) 
    
    ax[0][0].hist(df['petal width'], color='black'); 
    ax[0][0].set_ylabel('Count', fontsize=12) 
    ax[0][0].set_xlabel('Width', fontsize=12) 
    ax[0][0].set_title('Iris Petal Width', fontsize=14, y=1.01) 
    
    ax[0][1].hist(df['petal length'], color='black'); 
    ax[0][1].set_ylabel('Count', fontsize=12) 
    ax[0][1].set_xlabel('Lenth', fontsize=12) 
    ax[0][1].set_title('Iris Petal Lenth', fontsize=14, y=1.01) 
    
    ax[1][0].hist(df['sepal width'], color='black'); 
    ax[1][0].set_ylabel('Count', fontsize=12) 
    ax[1][0].set_xlabel('Width', fontsize=12) 
    ax[1][0].set_title('Iris Sepal Width', fontsize=14, y=1.01) 
    
    ax[1][1].hist(df['sepal length'], color='black'); 
    ax[1][1].set_ylabel('Count', fontsize=12) 
    ax[1][1].set_xlabel('Length', fontsize=12) 
    ax[1][1].set_title('Iris Sepal Length', fontsize=14, y=1.01) 
    
    plt.tight_layout()

上述代码的输出显示如图1-19所示。

![Image 1][]

图1-19

显然，这不是最有效的编码方法，但是对于展示`matplotlib`是如何工作的很有用处。请注意，我们现在是通过`ax`数组来绘制四个子插图，而不是之前例子中的单一子插图对象`ax`。新增加的代码是调用`plt.tight_layout()`，该方法将很好地自动调整子插图，以避免排版上显得过于拥挤。

现在来看看matplotlib所提供的一些其他类型的画图模式。一个有用的类型是散点图。这里，我们将在*x*轴和*y*轴分布绘画花瓣宽度和花瓣长度。

fig, ax = plt.subplots(figsize=(6,6)) 
    ax.scatter(df['petal width'],df['petal length'], color='green') 
    ax.set_xlabel('Petal Width') 
    ax.set_ylabel('Petal Length') 
    ax.set_title('Petal Scatterplot')

上述的代码生成了图1-20所示的输出。

![Image 1][]

图1-20

如前所述，我们可以添加多个子插图，来检视每个方面。

我们可以考察的另一种类型是简单的线图。这里来看看花瓣长度的插图。

fig, ax = plt.subplots(figsize=(6,6)) 
    ax.plot(df['petal length'], color='blue') 
    ax.set_xlabel('Specimen Number') 
    ax.set_ylabel('Petal Length') 
    ax.set_title('Petal Length Plot')

上述的代码生成了图1-21所示的输出。

基于这个简单的线图，我们已经可以看到对于每个类别存在鲜明的长度差别——请记住样本数据集在每个类别拥有50个排序的样例。这就告诉我们，花瓣长度很可能是用于区分类别的一个有用特征。

![Image 1][]

图1-21

让我们来看看`matplotlib`库中最后一个类型的图表：条形图。这也许是最为常见的图表之一。这里将使用三类鸢尾花中每个特征的平均值绘制一个条形图，而且为了让其更有趣，我们将使用堆积条形图，它附带了若干新的`matplotlib`特性。

fig, ax = plt.subplots(figsize=(6,6)) 
    bar_width = .8 
    labels = [x for x in df.columns if 'length' in x or 'width' in x] 
    ver_y = [df[df['class']=='Iris-versicolor'][x].mean() for x in labels] 
    vir_y = [df[df['class']=='Iris-virginica'][x].mean() for x in labels] 
    set_y = [df[df['class']=='Iris-setosa'][x].mean() for x in labels] 
    x = np.arange(len(labels)) 
    ax.bar(x, vir_y, bar_width, bottom=set_y, color='darkgrey') 
    ax.bar(x, set_y, bar_width, bottom=ver_y, color='white') 
    ax.bar(x, ver_y, bar_width, color='black') 
    ax.set_xticks(x + (bar_width/2)) 
    ax.set_xticklabels(labels, rotation=-70, fontsize=12); 
    ax.set_title('Mean Feature Measurement By Class', y=1.01) 
    ax.legend(['Virginica','Setosa','Versicolor'])

上述的代码生成图1-22所示的输出。

![Image 1][]

图1-22

为了生成条形图，我们需要将`x`和`y`的值传递给`.bar()`方法。在这种情况下，`x`值将只是我们感兴趣的特征的长度的数组，在这个例子中是4，或者是数据框中列的数量。函数`np.arange()`是产生这个数值的简单方法，但也可以轻松地手动输入这个数组。由于我们不想在x轴显示1到4，因此调用了`.set_xticklabels()`方法并传入想要显示的列名。为了让`x`轴的标签对齐，我们还需要调整标签之间的间隔。这就是为什么将`xticks`设置为`x`加上`bar_width`值的一半，而我们先前已经将`bar_width`设置为0.8。这里`y`值来自每个类别中特征的平均值。然后，通过调用`.bar()`绘制每个插图。需要注意的是，我们为每个序列传入一个`bottom`参数，这个参数将该序列的y点最小值设置为其下面那个序列的y点最大值。这就能创建堆积条形图。最后，添加了一个图例来描述每个序列。按照从顶部到底部条形放置的顺序，我们依次在图例中插入了相应的名称。

#### Seaborn库 ####

我们接下来将看到的可视化库被称为`seaborn`（`http://stanford.edu/~mwaskom/software/seaborn/index.html`）。它是专门为统计可视化而创建的库。事实上，`seaborn`可以和`pandas`数据框完美地协作，框中的列是特征而行是观测的样例。这种数据框的风格被称为整洁的数据，而且它是机器学习应用中最常见的形式。

现在让我们来看看`seaborn`的能力。

import seaborn as sns 
    sns.pairplot(df, hue="class")

仅仅通过这两行代码，我们就可以得到图1-23所示的输出。

![Image 1][]

图1-23

就在刚刚我们详细地讨论了`matplotlib`错综复杂的细微之处，而生成这张图的简单性却显而易见。仅仅使用了两行代码，所有的特征都已经被绘画出来，彼此对照并标上了正确的标签。那么，当`seaborn`使得这种可视化变得如此简单的时候，学习`matplotlib`是在浪费时间吗？幸运的是，情况并非如此，`seaborn`是建立在`matplotlib`之上的。事实上，我们可以使用所学的`matplotlib`知识来修改并使用`seaborn`。让我们来看看另一个可视化的例子。

fig, ax = plt.subplots(2, 2, figsize=(7, 7)) 
    sns.set(style='white', palette='muted') 
    sns.violinplot(x=df['class'], y=df['sepal length'], ax=ax[0,0]) 
    sns.violinplot(x=df['class'], y=df['sepal width'], ax=ax[0,1]) 
    sns.violinplot(x=df['class'], y=df['petal length'], ax=ax[1,0]) 
    sns.violinplot(x=df['class'], y=df['petal width'], ax=ax[1,1]) 
    fig.suptitle('Violin Plots', fontsize=16, y=1.03) 
    for i in ax.flat: 
         plt.setp(i.get_xticklabels(), rotation=-90) 
    fig.tight_layout()

以上代码行生成图1-24所示的输出。

![Image 1][]

图1-24

这里，我们为4个特征分别生成了小提琴图。小提琴图显示了特征的分布情况。例如，我们可以很容易地看到类别`irissetosa`的花瓣长度高度聚集在1～2厘米之间，而类别`iris-virginica`分散在4～7厘米之间。我们还可以看到，之前在构建`matplotlib`图形时使用了许多相同的代码。这里主要的区别在于加入了`sns.plot()`调用来取代之前的`ax.plot()`调用 。我们还使用了`fig.suptitle()`方法，在所有的子图上添加了一个总标题，而不是在每个单独的子图上各自添加标题。另一个明显的添加部分，是每个子图的遍历取代了之前`xticklabels`的轮换。我们调用`ax.flat()`，遍历每个子图的轴，并使用.setp()设置特定的属性。这可以让我们不再需要像之前`matplotlib`子图代码那样，单独地敲打`ax[0][0]…ax[1][1]`，并设置属性。

我们在这里使用的图是一个很好的开始，但是你可以使用matplotlib和seaborn创建上百种不同风格的图形。我强烈建议深入研究这两个库的文档，这将是非常值得的。

### 1.2.3　准备 ###

我们已经学到了很多有关检查数据的内容，现在让我们开始学习如何处理和操作数据。这里你将了解 `pandas`的`Series.map()`、`Series.apply()`、`DataFrame.apply()`、`DataFrame.applymap()和 DataFrame.groupby()`方法。这些对于处理数据而言是非常有价值的，而且在特征工程的机器学习场景下特别有用，我们将在后面的章节详细地讨论这个概念。

#### 1．Map ####

`Map`方法适用于序列数据，所以在我们的例子中将用它来转变数据框的某个列，它就是一个`pandas`的序列 。假设我们觉得类别的名字太长了，并且希望使用特殊的3字母代码系统对其进行编码。为了实现这点，我们将使用`map`方法并将一个Python字典作为其参数。这里将为每个单独的鸢尾花类型传入替换的文本。

df['class'] = df['class'].map({
        'Iris-setosa': 'SET', 'Iris-virginica': 
    'VIR', 'Iris-versicolor': 'VER'}) 
    df

前面的代码生成图1-25的输出。

![Image 1][]

图1-25

下面来看看这里做了些什么。我们在现有`class`列的每个值上运行了`map`的方法。由于每个值都能在Python字典中找到，所以它会被添加到被返回的序列。我们为返回序列赋予了相同的`class`名，所以它替换了原有的`class`列。如果我们选择了一个不同的名字，例如`short class`，那么这一列会被追加到数据框，然后我们将有初始的`class`列外加新的`short class`列。

我们还可以向`map`方法传入另一个序列或函数，来执行对某个列的转变，但这个功能在`apply` 方法也是可用的，下面这节会讨论该方法。字典的功能是`map`方法所独有的，这也是选择`map`而不是`apply`进行单列转变的最常见原因。现在让我们来看看`apply`方法。

#### 2．Apply ####

`Apply`的方法让我们既可以在数据框上工作，也可以在序列上工作。我们将从一个也能使用`map`的例子开始，然后再讨论只能使用`apply`的示例。

继续使用`iris`数据框，让我们根据花瓣的宽度来创建新的列。之前我们看到花瓣宽度的平均值为1.3。现在，在数据框中创建一个新的列——宽花瓣，它包含一个基于`petal width`列的二进制值。如果花瓣宽度等于或宽于中值，那么我们将其编码为1，而如果它小于中值，我们将其编码为0。为了实现这点，这里将在`petal width`这列使用`apply`方法。

df['wide petal'] = df['petal width'].apply(lambda v: 1 if v >= 1.3 else 0) 
    df

前面的代码生成图1-26所示的输出。

![Image 1][]

图1-26

这里发生了几件事情，让我们一步一步来看。首先，我们为所要创建的列名简单地使用了列选择的语法，向数据框追加一个新的列，在这个例子中是`wide petal`。我们将这个新列设置为`apply`方法的输出。这里在`petal width`列上运行`apply`，并返回了`wide petal`列的相应值。`Apply`方法作用于`petal width`列的每个值。如果该值大于或等于`1.3，函数返回1；否则，返回0`。这种类型的转换在机器学习领域是相当普遍的特征工程转变，所以最好熟悉如何执行它。

现在让我们来看看如何在数据框上使用`apply`，而不是在一个单独的序列上。现在将基于`petal area`来创建一个新的特征。

df['petal area'] = df.apply(lambda r: r['petal length'] * r['petal width'], 
    axis=1) 
    df

前面的代码生成图1-27的输出。

![Image 1][]

图1-27

请注意，这里不是在一个序列上调用`apply`，而是在整个数据框上。此外正是由于在整个数据框上调用了`apply`，我们传送了`axis=1的参数来告诉pandas`，我们要对行运用函数。如果传入了`axis=0`，那么该函数将对列进行操作。这里，每列都是被顺序地处理，我们选择将`petal length的值和petal width`的值相乘。得到的序列就将成为数据框中的`petal area列`。这种能力和灵活性使得`pandas`成为了数据操作不可或缺的工具。

#### 3．Applymap ####

我们已经学习了列的操作，并解释了如何在行上运作，不过，假设你想对数据框里所有的数据单元执行一个函数，那又该怎么办呢？这时`applymap`就是合适的工具了。这里看一个例子。

df.applymap(lambda v: np.log(v) if isinstance(v, float) else v)

前面的代码生成图1-28的输出。

![Image 1][]

图1-28

在这里，我们在数据框上调用了`applymap`，如果某个值是float类型的的实例，那么就会获得该值的对数（`np.log()`利用`numpy`库返回该值）。这种类型的检查，可以防止系统返回一个错误信息，或者是为字符串型的`class列`或整数形的`wide petal`列返回浮动值。`Applymap`的常见用法是根据一定的条件标准来转变或格式化每一个单元。

#### 4．Groupby ####

现在，让我们来看一个非常有用，但对于新pandas用户往往难以理解的操作——数据框`.groupby()`方法。我们将逐步分析若干例子，来展示这个最为重要的功能。

这个`groupby`操作就如其名——它基于某些你所选择的类别对数据进行分组。让我们使用`iris`数据集来看一个简单的例子。这里将回到之前的步骤，重新导入最初的`iris`数据集，并运行第一个`groupby`操作。

df.groupby('class').mean()

前面的代码生成图1-29所示的输出。

![Image 1][]

图1-29

系统按照类别对数据进行了划分，并且提供了每个特征的均值。让我们现在更进一步，得到每个类别完全的描述性统计信息。

df.groupby('class').describe()

前面的代码生成图1-30所示的输出。

![Image 1][]

图1-30

现在我们可以看到每个`class`完整的分解。再来看看其他一些可执行的`groupby`操作。之前，我们看出花瓣长度和宽度在不同类之间有一些比较明显的区别，这里让我们看看如何使用`groupby`来发现这一点。

df.groupby('petal width')['class'].unique().to_frame()

前面的代码生成图1-31所示的输出。

在这个例子中，我们通过和每个唯一类相关联的花瓣宽度，对类别进行分组。这里测量组的数量还是可管理的，但是如果这个数量将要增大很多，那么我们很可能需要将测量分割为不同的范围。正如之前看到的，这点可以使用`apply`方法来完成。

![Image 1][]

图1-31

现在来看一个自定义的聚集函数。

df.groupby('class')['petal width']\ 
    .agg({'delta': lambda x: x.max() - x.min(), 'max': np.max, 'min': np.min})

前面的代码生成图1-32所示的输出。

![1 4][]

图1-32

在这段代码中，我们根据类别来分组花瓣宽度的时候，使用`np.max和np.min`这两个函数（两个np函数来自numpy库），以及返回最大花瓣宽度减去最小花瓣宽度的`lambda`函数。这些都以字典的形式，传递给`.agg()`方法，以此返回一个将字典键值作为列名的数据框。可以仅仅运行函数本身或者传递函数的列表，不过列的名称所含信息量就更少了[\[1\]][1 5]。

> ![1 6][]　
> 
> 我们只是刚刚接触了`groupby`方法的一些功能，还有很多东西要学习，所以我建议你阅读这里的文档：`http://pandas.pydata.org/pandas-docs/stable/`。

对于准备阶段中如何操纵和准备数据，我们现在有了扎实的基本理解，而下一步就是建模。这里即将讨论Python机器学习生态系统中最为主要的一些库。

### 1.2.4　建模和评估 ###

对于统计建模和机器学习，Python有许多很优秀的、文档详实的库供选择。下面只谈及最流行的几个库。

#### 1．Statsmodels ####

我们要介绍的第一个库是`statsmodels`（`http://statsmodels.sourceforge.net/`）。

Statsmodels是用于探索数据、估计模型，并运行统计检验的Python包。在这里，让我们使用它来构建一个简单的线性回归模型，为`setosa`类中花萼长度和花萼宽度之间的关系进行建模。

首先，通过散点图来目测这两者的关系。

fig, ax = plt.subplots(figsize=(7,7)) 
    ax.scatter(df['sepal width'][:50], df['sepal length'][:50])
    ax.set_ylabel('Sepal Length') 
    ax.set_xlabel('Sepal Width') 
    ax.set_title('Setosa Sepal Width vs. Sepal Length', fontsize=14, 
    y=1.02)

前面的代码生成图1-33所示的输出。

![Image 1][]

图1-33

我们可以看到，似乎有一个正向的线性关系，也就是说，随着花萼宽度的增加，花萼长度也会增加。接下来我们使用statsmodels，在这个数据集上运行一个线性回归模型，来预估这种关系的强度。

import statsmodels.api as sm 
    
    y = df['sepal length'][:50] 
    x = df['sepal width'][:50] 
    X = sm.add_constant(x) 
    
    results = sm.OLS(y, X).fit() 
    print(results.summary())

前面的代码生成图1-34所示的输出。

图1-34所示的屏幕截图显示了这个简单回归模型的结果。由于这是一个线性回归，该模型的格式为`Y = Β0+Β1X`，其中`B0`为截距而`B1`是回归系数。在这里，最终公式是`Sepal Length = 2.6447 + 0.6909 × Sepal Width`。我们也可以看到，该模型的`R2`值是一个可以接受的`0.558`，而`p`值 （`Prob`）是非常显著的——至少对于这个类而言。

![Image 1][]

图1-34

现在让我们使用结果对象来绘制回归线。

fig, ax = plt.subplots(figsize=(7,7)) 
    ax.plot(x, results.fittedvalues, label='regression line') 
    ax.scatter(x, y, label='data point', color='r') 
    ax.set_ylabel('Sepal Length') 
    ax.set_xlabel('Sepal Width') 
    ax.set_title('Setosa Sepal Width vs. Sepal Length', fontsize=14, 
    y=1.02) 
    ax.legend(loc=2)

前面的代码生成图1-35所示的输出。

通过绘制`results.fittedvalues`，我们可以获取从模型所得的回归线。

在`statsmodels`包中，还有一些其他的统计函数和测试模块，我希望你能去探索它们。对于Python中标准的统计建模而言，这是一个非常有用的包。接下来，让我们开始学习Python机器学习包中的王者：`scikit-learn`。

#### 2．scikit-learn ####

scikit-learn是一个令人惊喜的Python库，作者们为其设计了无与伦比的文档，为几十个算法提供了统一的API接口。它建立在Python科学栈的核心模块之上，也就是NumPy、SciPy、pandas和matplotlib。scikit-learn覆盖的一些领域包括：分类、回归、聚类、降维、模型选择和预处理。

![Image 1][]

图1-35

我们来看看几个例子。首先，使用`iris`数据建立一个分类器，然后学习如何利用scikit-learn 的工具来评估得到的模型。

在scikit-learn中打造机器学习模型的第一步，是理解数据应该如何构建。独立变量应该是一个数字型的`n×m`纬的矩阵`X`、一个因变量y`和n×1`维的向量。该y向量可以是连续的数字，也可以是离散的数字，还可以是离散的字符串类型。然后将这些向量传递到指定分类器的`.fit()`方法。这是使用scikit-learn最大的好处，每个分类器都尽最大可能地使用同样的方法。如此一来，它们的交换使用易如反掌。

让我们来看看在第一个例子中，如何实现。

from sklearn.ensemble import RandomForestClassifier 
    from sklearn.cross_validation import train_test_split 
    
    clf = RandomForestClassifier(max_depth=5, n_estimators=10) 
    
    X = df.ix[:,:4] 
    y = df.ix[:,4] 
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, 
    test_size=.3) 
    
    clf.fit(X_train,y_train) 
    
    y_pred = clf.predict(X_test) 
    
    rf = pd.DataFrame(list(zip(y_pred, y_test)), columns=['predicted', 
    'actual']) 
    rf['correct'] = rf.apply(lambda r: 1 if r['predicted'] == 
    r['actual'] else 0, axis=1) 
    rf

前面的代码生成图1-36的输出。

![Image 1][]

图1-36

现在，让我们来看看下面的代码。

rf['correct'].sum()/rf['correct'].count()

这会生成图1-37的输出。

![Image 1][]

图1-37

在前面的几行代码中，我们建立、训练并测试了一个分类器，它在Iris数据集上具有95％的准确度。这里逐项分析每个步骤。在代码的前两行，我们做了几个导入，前两个是从scikit-learn，值得庆幸的是在import语句中其名字缩短为`sklearn`了。第一个导入的是一个随机森林分类器，第二个导入的是一个将数据分成训练组和测试组的模块。出于某些原因，这种数据切分在机器学习应用的构建中是很关键的。我们将在以后的章节讨论这些，现在只需要知道这是必需的。模块`train_test_split`还会打乱数据的先后顺序，这也是非常重要的，因为原有的顺序可能包含误导实际预测的信息。

> ![Image 1][]　
> 
> 在这本书中，我们将使用最新的Python版本，撰写本书的时候是版本`3.5`。如果你使用的Python是版本`2.x`，你需要添加额外的import语句，让整数的除法和Python `3.x`中的一样运作。没有这一行，你的准确度将被报告为`0`，而不是`95`%。该行是：
> 
>     from __future__ import division

在import语句之后，第一行看上去很奇怪的代码实例化了我们的分类器，这个例子中是随机森林分类器。这里选择一个使用`10`个决策树的森林，而每棵树最多允许五层的判定深度。如此实施的原因是为了避免过拟合（overfitting），我们将在后面的章节中深入讨论这个话题。

接下来的两行创建了*`X`*矩阵和*`y`*向量。初始的`iris`数据框包含四个特征：花瓣的宽度和长度，以及花萼的宽度和长度。这些特征被选中并成为独立特征矩阵*`X`*。最后一列，`iris`类别的名称，就成为了因变的*`y`*向量。

然后这些被传递到`train_test_split`方法，该方法将数据打乱并划分为四个子集，`X_train，X_test，y_train和y_test`。参数`test_size`被设置为`0.3`，这意味着数据集的30％将被分配给`X_test和y_test`部分，而其余的将被分配到训练的部分，`X_train`和`y_train`。

接下来，使用训练数据来拟合我们的模型。一旦模型训练完毕，再通过测试数据来调用分类器的预测方法。请记住，测试数据是分类器没有处理过的数据。预测的返回结果是预估标签的列表。然后，我们创建对应实际标签与预估标签的数据框。最终，我们加和正确的预测次数，并将其除以样例的总数，从而看出预测的准确率。现在让我们看看哪些特征提供了最佳的辨别力或者说预测能力。

f_importances = clf.feature_importances_f_names = df.columns[:4] 
    f_std = np.std([tree.feature_importances_ for tree in 
    clf.estimators_], axis=0) 
    
    zz = zip(f_importances, f_names, f_std) 
    zzs = sorted(zz, key=lambda x: x[0], reverse=True) 
    
    imps = [x[0] for x in zzs] 
    labels = [x[1] for x in zzs] 
    errs = [x[2] for x in zzs] 
    plt.bar(range(len(f_importances)), imps, color="r", yerr=errs, 
    align="center") 
    plt.xticks(range(len(f_importances)), labels);

从图1-38可以看出，正如我们根据之前可视化分析所作出的预期，花瓣的长度和宽度对于区分`iris`的类别而言，具有更好的辨别力。不过，这些数字究竟来自哪里？随机森林有一个名为`.feature_importances_`的方法，它返回特征在决策树中划分叶子节点的相对能力。如果一个特征能够将分组一致性地、干净拆分成不同的类别，那么它将具有很高的特征重要性。这个数字的总和将始终为1。也许你注意到，在这里我们已经包括了标准差，它将有助于说明每个特征有多么的一致。这是如此生成的：对于每个特征，获取每10棵决策树的特征重要性，并计算标准差。

![Image 1][]

图1-38

现在，让我们看看另一个使用scikit-learn的例子。现在，切换分类器并使用支持向量机（SVM）。

from sklearn.multiclass import OneVsRestClassifier 
    from sklearn.svm import SVC 
    from sklearn.cross_validation import train_test_split 
    
    clf = OneVsRestClassifier(SVC(kernel='linear')) 
    
    X = df.ix[:,:4] 
    y = np.array(df.ix[:,4]).astype(str) 
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, 
    test_size=.3) 
    clf.fit(X_train,y_train) 
    
    y_pred = clf.predict(X_test) 
    
    rf = pd.DataFrame(list(zip(y_pred, y_test)), columns=['predicted', 
    'actual']) 
    rf['correct'] = rf.apply(lambda r: 1 if r['predicted'] == 
    r['actual'] else 0, axis=1) 
    rf

前面的代码生成图1-39的输出。

![Image 1][]

图1-39

现在，让我们执行下面这行代码。

rf['correct'].sum()/rf['correct'].count()

前面的代码生成图1-40的输出。

![Image 1][]

图1-40

这里，我们将模型切换为支持向量机，而没有改变代码的本质。唯一的变化是引入了SVM而不是随机森林，以及实例化分类器的那一行代码（标签`y`需要一个小小的格式改变，这是因为SVM无法像随机森林分类器那样，将这些标签解释为NumPy的字符串）。

这些仅仅是scikit-learn能力的一小部分，但它应该可以说明这个伟大的工具对于机器学习应用而言强大的功能和力量。还有许多其他的机器学习库，我们在这里没有机会讨论，不过会在后面的章节中探讨，这里我强烈建议，如果你是第一次使用机器学习库，而又想要一个强大的通用工具，scikit-learn将是你明智的选择。

### 1.2.5　部署 ###

将一个机器学习模型放入生产环境时，有许多可用的选项。它基本上取决于应用程序的性质。部署小到在本地机器上运行cron作业，大到在Amazon EC2实例上部署全面的实现。

这里不会深入具体实施的细节，不过全书中我们将有机会研究不同的部署实例。

## 1.3　设置机器学习的环境 ##

本章已经介绍了一些可以通过pip（Python的包管理器）单独安装的库。不过，我强烈建议你安装预打包的解决方案，例如Continuum's Anaconda Python发行版。这是一个单一的可执行程序，包含几乎所有需要的软件包和依赖者。而且，因为这个发行版是针对Python科学栈的用户，它本质上是一个一劳永逸的解决方案。

Anaconda也包括软件包管理器，使得包的更新变得如此简单。

只需简单地键入`conda update <package_name>`，那么库就会被更新到最近的稳定版本。

## 1.4　小结 ##

在本章中，我们介绍了数据科学/机器学习的工作流程。我们学习了如何让数据一步步地通过流水线的每个阶段，从最初的获取一直到最终的部署。本章还涵盖了Python科学栈中最重要的一些功能库及其关键特性。

现在，我们将利用这方面的知识和经验，开始创造独特的、有价值的机器学习应用程序。在下一章，你将看到如何运用回归模型来发现一个便宜的公寓，让我们开始吧！

[Python]: https://link.juejin.im/?target=http%3A%2F%2Fwww.epubit.com.cn%2Fbook%2Fdetails%2F4658
[1]: https://user-gold-cdn.xitu.io/2017/6/22/690a4f0e2b47979768d24fa7d08b7182?imageView2/0/w/1280/h/960/format/webp/ignore-error/1
[Image 1]: 
[1 1]: https://user-gold-cdn.xitu.io/2017/6/22/8c31ddf22d450d1b4af789f87f40e015?imageView2/0/w/1280/h/960/format/webp/ignore-error/1
[1 2]: https://user-gold-cdn.xitu.io/2017/6/22/4f0d67cb46793a78df912aa8d5d23299?imageView2/0/w/1280/h/960/format/webp/ignore-error/1
[1 3]: https://user-gold-cdn.xitu.io/2017/6/22/9de7eb7bcb791cee004ba3290901cd74?imageView2/0/w/1280/h/960/format/webp/ignore-error/1
[1 4]: https://user-gold-cdn.xitu.io/2017/6/22/a8f5ede6c15091237f5ce5a4cb1b2d9b?imageView2/0/w/1280/h/960/format/webp/ignore-error/1
[1 5]: https://juejin.im/entry/594b5ecb1b69e60062a34d48#anchor11
[1 6]: https://user-gold-cdn.xitu.io/2017/6/22/530789eff83ef044d2a4176e34090afd?imageView2/0/w/1280/h/960/format/webp/ignore-error/1