精通 Sklearn 和 TensorFlow 预测性分析：1~5 全

一、回归和分类的集成方法

商业企业广泛使用高级分析工具，以解决使用数据的问题。 分析工具的目的是分析数据并提取相关信息，这些信息可用于解决问题或提高业务某些方面的表现。 它还涉及各种机器学习算法，通过这些算法我们可以创建预测模型以获得更好的结果。

在本章中，我们将探索一个可以大大改善基本预测模型表现的简单想法。

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

• 集成方法及其工作原理
• 集成回归方法
• 集成分类方法

集成方法及其工作原理

集成方法基于一个非常简单的思想：我们不是使用单个模型进行预测，而是使用许多模型，然后使用某种方法来汇总预测。 具有不同的模型就像具有不同的观点，并且已经证明，通过汇总提供不同观点的模型，可以得到不同的结果。 预测可以更准确。 这些方法进一步提高了单个模型的通用性，因为它们降低了选择效果不佳的分类器的风险：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HzYwu22i-1681654248105)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/7ea084f3-b32d-4323-b493-cce263e07286.png)]

在上图中，我们可以看到每个对象属于三个类别之一：三角形，圆形和正方形。 在这个简化的示例中，我们有两个特征可以将对象分离或分类为不同的类。 如您在这里看到的，我们可以使用三个不同的分类器，并且这三个分类器都代表不同的方法并具有不同种类的决策边界。

集成学习将所有这些单独的预测合并为一个预测。 通过组合三个边界进行的预测通常比单个模型所产生的预测具有更好的表现。 这是集成方法（也称为集成学习）背后的简单思想。

最常用的集成方法如下：

• 自举采样
• 装袋
• 随机森林
• 提升

在对这些方法进行高级解释之前，我们需要讨论一种非常重要的统计技术，称为自举抽样。

自举采样

许多集成学习方法都使用一种称为引导抽样的统计技术。 数据集的引导样本是另一个数据集，它是通过对原始数据集中的观测值带放回随机抽样而获得的。

例如，该技术在统计中大量使用。 它用于估计样本统计量的标准误差，例如平均值或标准差。

让我们通过看下面的图来更多地了解这项技术：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-df50KgPG-1681654248106)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/2fedfc25-71ae-4f2f-a64c-488eb2c170a9.png)]

假设我们有 1 到 10 的人口，可以认为是原始人口数据。 要获得引导程序样本，我们需要从原始数据中抽取 10 个样本进行替换。 假设您戴着帽子，用 10 张卡片写下了 10 个数字； 对于样本的第一个元素，您从帽子上随机拿出一张卡片并将其写下来，然后将卡片放回帽子中，此过程一直进行到获得 10 个元素为止。 这是您的引导程序示例。 如您在前面的示例中所见，在引导程序样本中，9重复了三次。

用替换对数字进行重采样可以提高真实总体数据的准确率。 它还有助于理解重采样过程中涉及的各种差异和特征，从而提高其准确率。

装袋

装袋（也称为引导聚合）是减少机器学习模型中差异的通用过程。 它基于自举抽样技术，通常与回归树或分类树一起使用，但是原则上该装袋技术可以与任何模型一起使用。

装袋过程涉及以下步骤：

1. 我们选择要使用的估计量或单个模型的数量。 让我们将其视为参数B。
2. 我们使用训练集中的自举抽样从B抽取样本数据集并进行替换。
3. 对于这些训练数据集中的每一个，我们将机器学习模型拟合到每个引导样本中。 这样，我们获得了B参数的单独预测变量。
4. 我们通过汇总所有单个预测来获得整体预测。

在回归问题中，获得总体预测的最常见方法是找到所有单个预测的平均值。

在分类问题中，获得汇总预测的最常见方法是进行多数表决。 多数投票可以通过一个例子来解释。 假设我们有 100 个单独的预测变量，其中 80 个投票针对某一特定类别。 然后，我们选择该类别作为汇总预测。 这就是多数表决的意思。

随机森林

该集成方法是专门为回归树或分类树创建的。 它与装袋非常相似，因为在这里，每棵树都是在训练数据集的引导样本上训练的。 装袋的不同之处在于，它使模型非常强大，并且在从树中拆分节点时，选择的拆分在特征的随机子集中是最好的。 因此，每个预测变量都会考虑特征的随机子集。 这具有使每个单独的预测变量稍微更差，更偏颇的效果，但是由于各个预测变量的相关性，总体上总体上要比单个预测变量更好。

提升

提升是集成学习的另一种方法。 提升的方法很多，但是人们用于整体学习的最成功，最流行的方法之一就是 AdaBoost 算法。 也称为自适应增强。 该算法背后的核心思想是，我们可以拟合一系列弱学习器，而不是单独拟合许多单独的预测变量。 下一个算法取决于上一个算法的结果。 在 AdaBoost 算法中，每次迭代都会对所有这些样本进行加权。 此处的训练数据根据以前的单个学习器或单个模型的结果进行加权。

例如，在分类中，基本思想是错误分类的示例会增加权重，而正确分类的示例会失去权重。 因此，序列中的下一个学习器或序列中的下一个模型更多地关注错误分类的示例。

集成回归方法

关于回归，我们将训练这些不同的模型，然后比较它们的结果。 为了测试所有这些模型，我们将需要一个样本数据集。 我们将使用它来在给定的数据集上实现这些方法，并了解这如何帮助我们提高模型的表现。

钻石数据集

让我们通过使用不同的集成学习模型对钻石价格进行实际预测。 我们将使用钻石数据集（可在此处找到）。 除其他特征外，该数据集的价格接近 54,000 钻石。 以下是此数据集中的特征：

• 特征信息：具有 53,940 行和 10 个变量的数据帧
• 价格：美元价格

以下是九种预测特征：

• carat：此特征代表钻石的重量（0.2-5.01）
• cut：此特征代表剪切的质量（Fair，Good，Very Good，Premium和Ideal）
• color：此特征代表钻石的颜色，从J（最差）到D（最佳）
• clarity：此特征代表钻石净度的测量值（I1（最差），SI2，SI1，VS2，VS1，VVS2，VVS1，IF （最好））
• x：此特征代表以毫米为单位的钻石长度（0-10.74）
• y：此特征代表以毫米为单位的钻石宽度（0-58.9）
• z：此特征代表以毫米为单位的钻石深度（0-31.8）
• depth：此特征表示z / mean(x, y) = 2 * z / (x + y)（43-79）
• table：此特征代表钻石顶部相对于最宽点的宽度（43-95）

x，y和z变量表示钻石的大小。

我们将使用的库为numpy，matplotlib和pandas。 为了导入这些库，可以使用以下代码行：

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

以下屏幕截图显示了我们用于调用原始数据集的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xobWaSoH-1681654248107)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/744cd5bf-030d-4c57-9858-8f8ea652dee5.png)]

前面的数据集具有一些数值特征和一些分类特征。 在这里，53,940 是我们在该数据集中拥有的样本的确切数量。 现在，为了对这些分类特征中的信息进行编码，我们使用一键编码技术将这些分类特征转换为伪特征。 其背后的原因是因为scikit-learn仅适用于数字。

以下屏幕截图显示了用于将分类特征转换为数字的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d1PyeXVQ-1681654248107)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/3b9400c6-af95-46f0-9950-b791d06199ca.png)]

在这里，我们可以看到如何使用pandas中的get_dummies函数来执行此操作。 最终数据集看起来与以下屏幕快照中的数据集相似：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8g5PUDJR-1681654248107)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/7bb25e6e-cf8d-4f81-bca4-b6424662d894.png)]

在这里，对于分类变量中的每个类别，我们都有虚拟特征。 当类别存在时，此处的值为1；当特定钻石中不存在类别时，此处的值为0。

现在，为了重新缩放数据，我们将使用RobustScaler方法将所有特征转换为相似的比例。

以下屏幕快照显示了用于导入train_test_split函数和RobustScaler方法的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jK3N0XhP-1681654248108)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/f0f42b97-e3c0-415a-b423-f8cf1299ecf6.png)]

在这里，我们提取X矩阵中的特征，提及目标，然后使用scikit-learn中的train_test_split函数将数据分为两组。

训练不同的回归模型

以下屏幕快照显示了我们将用于记录这些模型的指标和表现指标的数据帧。 由于这是一项回归任务，因此我们将使用均方误差。 在这里的列中，我们将使用四个模型。 我们将使用KNN，Bagging，RandomForest和Boosting变量：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a4tWeJzH-1681654248108)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/7372d44f-c895-45b9-8bce-e90ee96cd9a7.png)]

KNN 模型

K 最近邻（KNN）模型不是整体学习模型，但在简单模型中表现最佳：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ng5Ie9LR-1681654248108)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/49b9ce91-a006-4b09-b2e9-021e1ca3a76e.png)]

在前面的模型中，我们可以看到制作 KNN 时使用的过程。 我们将使用 20 个邻居。 我们正在使用euclidean度量来测量点之间的距离，然后将训练模型。 此处，由于该值仅为1（均方误差），因此可以保存表现指标。

装袋模型

装袋是一种整体学习模型。 装袋方法可以使用任何估计器。 因此，让我们来看一下使用 KNN 的情况，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JShqV73W-1681654248109)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/6e77b966-f186-47b0-a62d-df853ab1477c.png)]

使用n_estimators参数，我们可以产生 15 个独立估计器的集合。 结果，这将产生训练数据集的 15 个引导程序样本，然后，在每个这些样本中，它将使这些 KNN 回归变量之一与 20 个邻居匹配。 最后，我们将使用装袋法获得各个预测。 该算法用于给出单个预测的方法是多数表决。

随机森林模型

随机森林是另一个整体学习模型。 在这里，我们从scikit-learn中的ensemble子模块中获取所有集成学习对象。 例如，在这里，我们使用RandomForestRegressor方法。 以下屏幕截图显示了用于此模型的算法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NafUnBA6-1681654248109)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e9a128fc-153c-45ba-baeb-6497cbb42d7b.png)]

因此，在我们生成包含 50 个单独预测变量的森林的情况下，此算法将生成 50 个单独的树木。 每棵树将具有16的max_depth，然后将通过多数表决再次产生单个预测。

提升模型

提升也是一种整体学习模型。 在这里，我们使用AdaBoostRegressor模型，我们将再次产生50估计器。 以下屏幕截图显示了用于此模型的算法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MfuC7dtm-1681654248109)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/a8b9a936-0158-41a2-a251-428a10e3d4e2.png)]

以下屏幕截图显示了训练所有这些模型后获得的train_mse和test_mse结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mttZfdLO-1681654248109)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c9526e11-4aca-41c5-b379-5886696eb13a.png)]

以下屏幕截图显示了算法，并根据测试均方误差的值对所有这些模型进行了比较。 借助水平条形图显示结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tTtLzoqe-1681654248110)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/12d93d64-a55f-4309-b819-93c9523166cf.png)]

现在，当我们比较所有这些模型的结果时，我们可以看到随机森林模型是最成功的。 装袋模型和 KNN 模型分别排在第二和第三。 这就是为什么我们将 KNN 模型与装袋模型一起使用的原因。

以下屏幕截图显示了在测试数据集时用于在预测价格和观察到的价格之间生成图形表示的算法，还显示了随机森林模型的表现：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LNY8Bjo3-1681654248110)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/89828296-8384-4cf6-98be-298ad1722860.png)]

通过predict API 或predict方法再次使用此模型，我们可以获得单独的预测。

例如，让我们预测从测试数据集中获得的前十个预测的值。 以下算法显示了由该随机森林模型做出的预测，该预测又向我们显示了来自测试数据集的钻石的真实价格和预测价格：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BVsS7M07-1681654248110)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/fe7c964b-d9ad-4610-8191-f77921c308d7.png)]

从此屏幕截图中，我们可以看到Real price和Predicted price的值非常接近，无论是昂贵的钻石还是便宜的钻石。

将集成方法用于分类

现在，我们已经熟悉了集成学习和集成方法的基本概念。 现在，我们将实际使用这些方法在使用各种机器学习算法的模型构建中进行比较，并比较它们产生的结果。 为了实际测试所有这些方法，我们将需要一个样本数据集，以便在给定的数据集上实现这些方法，并了解这如何帮助我们提高模型的表现。

预测信用卡数据集

让我们以信用卡数据集为例。 该数据集来自台湾的一家金融机构，可以在以下位置找到。 请看以下屏幕截图，该屏幕截图显示了数据集的信息及其特征：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LOarkB6u-1681654248110)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/4843c2d6-cf4e-4e11-8f8f-8f0707ac43b8.png)]

在这里，我们具有有关每个客户的以下详细信息：

• 它包含限额余额，即使用信用卡提供给客户的信用限额
• 然后，我们具有有关每个客户的个人信息的一些特征，例如性别，教育程度，婚姻状况和年龄
• 我们也有过往付款记录
• 我们还有账单上的金额
• 我们拥有上个月至六个月前的账单金额和先前付款金额的历史记录，这是由客户完成的

有了这些信息，我们将预测下个月客户的付款状态。 我们将首先对这些特征进行一些转换，以使其更易于解释。

在这种情况下，肯定类别将是默认类别，因此数字 1 表示属于默认状态类别的客户，数字 0 表示已支付信用卡会费的客户。

现在，在开始之前，我们需要通过运行一些命令来导入所需的库，如以下代码片段所示：

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

以下屏幕快照显示了用于准备信用卡数据集的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YBO6vIjk-1681654248111)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/fe6dbac4-e195-481e-8831-add56f69a0de.png)]

让我们在grad _school，university和high_school中产生用于教育的虚拟特征。 不用sex一词，使用male虚拟特征，而不是使用婚姻，让我们使用married函数。 当此人结婚时，此特征的值为 1，否则为 0。 对于pay_1函数，我们将做一些简化过程。 如果我们在此处看到一个正数，则表示该客户在i个月内延迟付款。 这表示ID为 1 的客户将付款延迟了前两个月。 我们可以看到，三个月前，他/她的付款没有延迟。 这是数据集的样子：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hWj2oQft-1681654248111)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/f4ab3d2e-f4b8-4deb-a55d-80d918758c2d.png)]

在拟合模型之前，我们要做的最后一件事就是重新缩放所有特征，因为，正如我们在此处看到的那样，我们拥有的特征比例非常不同。 例如，limit_bal的规模与age的规模大不相同。

这就是为什么我们将使用scikit-learn中的RobustScaler方法-尝试将所有特征转换为相似的比例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ufdGPbT-1681654248111)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/a7a7c24d-f772-4668-8a3c-cfd8d7bb559c.png)]

正如我们在最后一行代码中的上一个屏幕快照中所看到的，我们将数据集划分为训练集和测试集，然后在下面，CMatrix函数用于为每个模型打印混淆矩阵。 以下代码片段中说明了此函数：

def CMatrix(CM, labels=['pay', 'default']):
    df = pd.DataFrame(data=CM, index=labels, columns=labels)
    df.index.name='TRUE'
    df.columns.name='PREDICTION'
    df.loc['Total'] = df.sum()
    df['Total'] = df.sum(axis=1)
    return df

训练不同的回归模型

下面的屏幕快照显示了一个我们要保存表现的数据帧。 我们将运行四个模型，即逻辑回归，装袋，随机森林和增强：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eDoiqfFM-1681654248111)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c745a454-b945-46c8-9d98-ab5ee3142f24.png)]

在这种情况下，我们将使用以下评估指标：

• accuracy：此度量标准衡量模型正确预测违约者和非违约者的频率
• precision：此指标将在模型预测默认值以及模型正确的频率时出现
• recall：此指标将是模型可以正确预测的实际默认违约者的比例

其中最重要的是recall指标。 其背后的原因是我们希望最大化模型所识别的实际默认值的比例，因此选择具有最佳召回率的模型。

逻辑回归模型

与scikit-learn中一样，我们只是导入对象，然后实例化估计量，然后将训练集X和训练集Y传递给fit()方法。 首先，我们将预测测试数据集，然后得出准确率，准确率和召回率得分。 以下屏幕截图显示了代码和混淆矩阵作为输出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ajtlPh8M-1681654248111)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/6d069752-6b15-482d-9354-c6589c2ca984.png)]

稍后，我们将把它们保存到我们刚刚创建的pandas数据帧中。

装袋模型

使用集成学习技术中的方法训练装袋模型涉及使用逻辑回归方法导入装袋分类器。 为此，我们将拟合其中的 10 个逻辑回归模型，然后使用装袋将 10 个单独的预测合并为一个预测。 之后，我们将其保存到指标数据帧中。

以下屏幕截图显示了代码和混淆矩阵作为输出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A19eMOfJ-1681654248112)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/84e409fc-7e30-4321-8f88-57c0926c643c.png)]

随机森林模型

要使用随机森林模型执行分类，我们必须导入RandomForestClassifier方法。 例如，让我们采用 35 棵单独的树，每棵树的max_depth为20。 max_features参数告诉scikit-learn，在确定可能的特征之间的最佳划分时，我们应该使用所拥有特征总数的平方根。 这些都是我们可以调整的超参数。

以下屏幕截图显示了代码和混淆矩阵作为输出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-55uraEki-1681654248112)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/667a44c8-3ce3-4e59-964b-1263b7b0b470.png)]

提升模型

在提升模型的分类中，我们将使用AdaBoostClassifier对象。 在这里，我们还将使用50估计器来组合各个预测。 我们将在这里使用的学习率是0.1，这是该模型的另一个超参数。

以下屏幕截图显示了代码和混淆矩阵：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZOe3xT0L-1681654248112)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/4b51908b-ba6c-4b3a-adc8-0a8728badee8.png)]

现在，我们将比较四个模型，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tFWYGdsv-1681654248112)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/f880f3a8-3521-4ee4-a837-7277b036abb9.png)]

上面的屏幕截图显示了这四个模型的相似精度，但是对于此特定应用，最重要的指标是recall指标。

以下屏幕截图显示，具有最佳召回率和准确率的模型是随机森林模型：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yaqGfKoP-1681654248112)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/7505e831-8e35-4fb1-b5a2-ba85059cb6e7.png)]

前面的屏幕快照证明，随机森林模型总体上优于其他模型。

要查看precision，recall和threshold之间的关系，我们可以使用scikit-learn中的precision_recall_curve函数。 在这里，传递预测值和实际观测值，然后我们得到的结果将包含使我们能够生成precision_recall_curve函数代码的对象。

以下屏幕截图显示了scikit-learn中precision_recall_curve函数的代码：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vb9JzsPf-1681654248113)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e302b9c0-37ad-41fb-ba88-8fd8b9ebd89e.png)]

现在，以下屏幕快照将可视化使用随机森林模型和逻辑回归模型时精度和召回率之间的关系：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cc9I3gfy-1681654248113)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/480e2a82-f60d-4756-8889-a7dacaf3e7f7.png)]

前面的屏幕快照显示，随机森林模型更好，因为它位于逻辑回归曲线之上。 因此，对于0.30的精度，与逻辑回归模型相比，使用随机森林模型获得的召回率更高。

要查看RandomForestClassifier方法的表现，我们更改了分类阈值。 例如，我们将分类阈值设置为0.12，那么我们将获得30的精度和84的召回率。 该模型将正确预测 84% 的可能违约者，这对于金融机构将非常有用。 这表明增强模型对此优于逻辑回归模型。

以下屏幕截图显示了代码和混淆矩阵：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LSNdgI93-1681654248113)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/251c8b59-4160-4ffe-821f-185c7b13f6ae.png)]

特征重要性是我们在使用随机森林模型时获得的非常重要的东西。 scikit-learn库针对我们在模型中使用的每个特征，计算该特征重要性度量。 内部计算使我们能够获得预测中每个特征重要性的度量。

以下屏幕截图显示了这些特征的可视化，因此强调了使用RandomForestClassifier方法的重要性：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lEkwnlRm-1681654248113)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/731b8ad3-d783-4308-a3a7-a442087ee7ee.png)]

预测客户是否将在下个月违约或客户是否在前一个月违约的最重要特征是pay_1。 在这里，我们只需要验证客户是否在上个月付款。 该模型的另一个重要特征是两个月的帐单金额，而另一个重要特征是年龄。

对于预测目标而言不重要的特征是性别，婚姻状况和客户的教育程度。

总体而言，随机森林模型已被证明比逻辑回归模型更好。

根据无免费午餐定理，没有一个模型可以最好地解决每个数据集中的每个问题。 这意味着整体学习不能总是胜过简单的方法，因为有时简单的方法比复杂的方法表现更好。 因此，对于每个机器学习问题，我们必须使用简单的方法而不是复杂的方法，然后评估这两种方法的表现以获得最佳结果。

总结

在本章中，我们介绍了不同的集成方法，例如引导程序采样，装袋，随机森林和增强方法，并通过一些示例说明了它们的工作原理。 然后，我们将它们用于回归和分类。 对于回归，我们以菱形数据集为例，还训练了一些 KNN 和其他回归模型。 后来，对它们的表现进行了比较。 为了进行分类，我们以信用卡数据集为例。 同样，我们训练了所有回归模型。 我们比较了它们的表现，发现随机森林模型的表现最佳。

在下一章中，我们将研究 K 折交叉验证和参数调整。 我们将比较具有 K 折交叉验证的不同集成学习模型，然后，我们将使用 K 折交叉验证进行超参数调优。

二、交叉验证和参数调整

预测分析涉及对未知事件进行预测。 我们使用它来生成可概括数据的模型。 为此，我们使用一种称为交叉验证的技术。

交叉验证是一种评估技术，用于评估统计分析结果的一种验证技术，该结果可推广到一个独立的数据集，该数据集提供了样本外准确率的度量。 它通过将数据的几个随机分区平均为训练样本和测试样本来完成任务。 它通常通过对参数的几个可能值进行交叉验证并选择给出最低交叉验证平均误差的参数值来进行超参数调优。

交叉验证有两种：穷举性和非穷举性。 K 折是非穷举性交叉验证的一个示例。 这是一种用于对模型表现进行更准确评估的技术。 使用 k 折交叉验证，我们可以进行超参数调优。 这是关于为我们的模型选择最佳的超参数。 k 折交叉验证和超参数调优等技术对于构建出色的预测分析模型至关重要。 交叉验证有很多类型或方法，例如，保留交叉验证和 k 折交叉验证。

在本章中，我们将涵盖以下主题：

• 保留交叉验证
• K 折交叉验证
• 将模型与 K 折交叉验证进行比较
• 超参数调优简介

保留交叉验证

在保留交叉验证中，我们保留了一定百分比的观察值，因此我们得到了两个数据集。 一个称为训练数据集，另一个称为测试数据集。 在这里，我们使用测试数据集计算评估指标，其余数据用于训练模型。 这是保留交叉验证的过程。

保留交叉验证的主要优点在于，它非常易于实现，并且是一种非常直观的交叉验证方法。

这种交叉验证的问题在于，它为模型的评估指标提供了一个估计。 这是有问题的，因为某些模型依赖于随机性。 因此，原则上，由于随机机会，有时在测试中计算出的评估指标可能会有很大差异。 因此，保留交叉验证的主要问题在于，我们只能获得评估指标的一个估计值。

K 折交叉验证

在 k 折交叉验证中，我们基本上会进行多次交叉验证。 因此，在 K 折交叉验证中，我们将数据集划分为k个相等大小的样本。 在许多k子样本中，保留了一个子样本作为用于测试模型的验证数据，其余k-1子样本用作训练数据。 然后，此交叉验证过程重复k次，每个k子样本中的每一个仅被使用一次作为验证数据。 然后可以将k结果平均，以产生单个估计。

以下屏幕截图显示了 5 倍交叉验证的直观示例（k = 5）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HsWR9s3q-1681654248113)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/da18d7be-8cc3-4aa7-a092-e74201a63185.png)]

在这里，我们看到我们的数据集分为五个部分。 我们将第一部分用于测试，其余部分用于训练。

以下是我们采用 5 倍交叉验证方法执行的步骤：

1. 我们对评估指标进行了首次估计。
2. 我们将第二部分用于测试，其余部分用于训练，然后使用它来获得评估指标的第二估计。
3. 我们将第三部分用于测试，将其余部分用于训练，依此类推。 这样，我们获得了评估指标的五种估计。

在 K 折交叉验证中，观察到评估矩阵的k估计后，取其平均值。 这将使我们可以更好地估计模型的表现。 因此，我们可以通过 K 折交叉验证获得n个估计数，而不是仅对这一评估指标进行一次估计，然后取平均值，以获得对表现的更好估计。 该模型。

如此处所示，k 折交叉验证方法的优势在于它不仅可以用于模型评估，而且还可以用于超参数调优。

在此验证方法中，k的公共值为 5 和 10。

以下是 k 折交叉验证的变体：

• 重复交叉验证：在重复交叉验证中，我们多次执行 K 折交叉验证。 因此，如果我们希望对评估指标进行 30 次估计，则可以进行 6 次 5 倍交叉验证。 因此，我们将获得 30 个评估指标的估计值。
  
• 留一法（LOO）交叉验证：在这种方法中，我们将除一点之外的整个数据集用于训练。 我们将这一点用于评估，然后对数据集中的每个数据点重复此过程。
  

如果我们有数百万个点，则此验证方法的计算量将非常昂贵。 在这种情况下，我们使用重复的 K 折交叉验证，因为这种验证方法将为我们提供相对较好的结果。

实现 k 折交叉验证

让我们以diamond数据集为例来了解 K 折交叉验证的实现。

为了在scikit-learn中执行 K 折交叉验证，我们首先必须导入将要使用的库。 以下代码段显示了用于导入库的代码：

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

第二步是准备在本示例中使用的diamond数据集的数据集。 下面显示了用于为此数据集准备数据的代码：

# importing data
data_path= '../data/diamonds.csv'
diamonds = pd.read_csv(data_path)
diamonds = pd.concat([diamonds, pd.get_dummies(diamonds['cut'], prefix='cut', drop_first=True)],axis=1)
diamonds = pd.concat([diamonds, pd.get_dummies(diamonds['color'], prefix='color', drop_first=True)],axis=1)
diamonds = pd.concat([diamonds, pd.get_dummies(diamonds['clarity'], prefix='clarity', drop_first=True)],axis=1)
diamonds.drop(['cut','color','clarity'], axis=1, inplace=True)

准备好数据后，我们将创建用于建模的对象。 下面显示了用于创建建模对象的代码：

from sklearn.preprocessing import RobustScaler
target_name = 'price'
robust_scaler = RobustScaler()
X = diamonds.drop('price', axis=1)
X = robust_scaler.fit_transform(X)
y = diamonds[target_name]
# Notice that we are not doing train-test split
#X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=55)

这与我们在第 1 章，“回归和分类的集成方法”中使用的单元格相同。 此处的区别在于我们不使用train_test_split函数。 在这里，我们正在生成X矩阵，该矩阵包含所有特征并具有我们的目标函数。 因此，我们有了X矩阵和y向量。

为了训练模型，我们将实例化RandomForestRegressor函数，该函数在此数据集的第 1 章 ，“回归和分类集成方法”中是最佳模型。 。 以下显示了用于实例化RandomForestRegressor函数的代码：

from sklearn.ensemble import RandomForestRegressor
RF = RandomForestRegressor(n_estimators=50, max_depth=16, random_state=123, n_jobs=-1)

为了执行 K 折交叉验证，我们从scikit-learn中的model_selection模块导入cross_validate函数。 下面显示了用于导入cross_validate函数的代码：

# this will work from sklearn version 0.19, if you get an error 
# make sure you upgrade: $conda upgrade scikit-learn
from sklearn.model_selection import cross_validate

此cross_validate函数的工作方式如下：

• 我们提供了估计器，它将是RandomForestRegressor函数。 下面显示了用于应用RandomForestRegressor函数的代码：

scores = cross_validate(estimator=RF,X=X,y=y,
 scoring=['mean_squared_error','r2'],
 cv=10, n_jobs=-1)

在这里，我们传递X对象和y对象。

• 我们提供了一组我们要评估的模型和数据集指标。 在这种情况下，使用mean_squared_error函数和r2指标进行评估，如前面的代码所示。 在这里，我们在cv中传递k的值。 因此，在这种情况下，我们将进行十倍交叉验证。

我们从此cross_validate函数获得的输出将是带有相应矩阵的字典。 为了更好地理解，将输出转换为数据帧。 以下屏幕快照显示了用于可视化数据帧和数据帧输出中的分数的代码：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0y3YMgPR-1681654248114)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/9856da4f-8d3d-476e-a72e-661065f019ad.png)]

在这里，我们应用test_mean_squared_error和test_r2，这是我们要评估的两个指标。 经过评估，我们获得了train_mean_squared_error值和test_r2集。 因此，我们对测试指标感兴趣。

为了更好地评估模型的表现，我们将对所有单个测量值进行平均（均值）。

下面显示了用于获取Mean test MSE和Mean test R-squared值并显示其值的输出的代码：

print("Mean test MSE:", round(scores['test_mean_squared_error'].mean()))
print("Mean test R-squared:", scores['test_r2'].mean())

因此，在平均上，我们看到测试 MSE 的平均值是我们在此处拥有的值以及其他指标的平均值，即 R 平方评估指标。

将模型与 K 折交叉验证进行比较

由于 k 折交叉验证方法被证明是一种更好的方法，因此它更适合于比较模型。 其背后的原因是 K 折交叉验证对评估指标给出了很多估计，并且对这些估计求平均后，我们可以更好地评估模型表现。

下面显示了用于导入库以比较模型的代码：

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

导入库后，我们将导入diamond数据集。 下面显示了用于准备此diamond数据集的代码：

# importing data
data_path= '../data/diamonds.csv'
diamonds = pd.read_csv(data_path)
diamonds = pd.concat([diamonds, pd.get_dummies(diamonds['cut'], prefix='cut', drop_first=True)],axis=1)
diamonds = pd.concat([diamonds, pd.get_dummies(diamonds['color'], prefix='color', drop_first=True)],axis=1)
diamonds = pd.concat([diamonds, pd.get_dummies(diamonds['clarity'], prefix='clarity', drop_first=True)],axis=1)
diamonds.drop(['cut','color','clarity'], axis=1, inplace=True)

现在，我们必须在准备好要进行模型比较的数据集之后准备要进行建模的对象。 下面显示了用于准备建模对象的代码。 这里，我们有X矩阵，显示了特征，以及y向量，它是此数据集的目标：

from sklearn.preprocessing import RobustScaler
target_name = 'price'
robust_scaler = RobustScaler()
X = diamonds.drop('price', axis=1)
X = robust_scaler.fit_transform(X)
y = diamonds[target_name]

在这里，我们将比较 KNN 模型，随机森林模型和装袋模型。 在这些模型中，使用十倍交叉验证，我们将使用KNNRegressor，RandomForestRegressor和AdaBoostRegressor函数。

然后，我们将导入cross_validate函数。 下面显示了用于导入这三个模型的cross_validate函数的代码：

from sklearn.neighbors import KNeighborsRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import AdaBoostRegressor
from sklearn.model_selection import cross_validate

下一步是使用cross_validate函数比较模型。 下面显示了用于比较这三种模型的代码块：

## KNN
knn = KNeighborsRegressor(n_neighbors=20, weights='distance', metric='euclidean', n_jobs=-1)
knn_test_mse = cross_validate(estimator=knn,X=X,y=y,
 scoring='mean_squared_error', 
 cv=10, n_jobs=-1)['test_score']
## Random Forests
RF = RandomForestRegressor(n_estimators=50, max_depth=16, random_state=55, n_jobs=-1)
RF_test_mse = cross_validate(estimator=RF,X=X,y=y,
 scoring='mean_squared_error', 
 cv=10, n_jobs=-1)['test_score']
## Boosting
boosting = AdaBoostRegressor(n_estimators=50, learning_rate=0.05, random_state=55) 
boosting_test_mse = cross_validate(estimator=boosting,X=X,y=y,
 scoring='mean_squared_error', 
 cv=10, n_jobs=-1)['test_score']

在这里，我们看到了将用于每个模型的测试评估指标的结果。 我们使用mean_squared_error函数。 对于每个模型，我们使用十倍交叉验证，得到结果后，我们将获得test_score变量。 在这种情况下，此test_score变量是均方误差，如以下代码所示：

mse_models = -1*pd.DataFrame({'KNN':knn_test_mse,
 'RandomForest': RF_test_mse,
 'Boosting':boosting_test_mse})

以下屏幕截图显示了针对每个模型运行十倍交叉验证后获得的结果代码，并且该表还显示了针对三个模型的评估指标的 10 个估计：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rZl5exWf-1681654248114)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/3371935f-fe8f-49f7-97e0-b4f194856d59.png)]

该表显示了每个模型的估计值的许多变化。 要知道任何模型的实际表现，我们取结果的平均值。 因此，在上图中，我们取所有值的平均值，然后将其绘制出来。

以下屏幕截图显示了用于获取均值的代码，并显示了每个模型的平均 MSE 值的图表：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J8uV7KP2-1681654248114)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/a47895c7-c5aa-4670-896b-0eddabf074f6.png)]

平均而言，随机森林模型在这三个模型中表现最好。 因此，在取平均值之后，第二位进入 KNN 模型，而提升模型则获得最后一位。

下图显示了用于获取这些评估指标的箱形图和三个模型的箱形图的代码：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cR0X4hyz-1681654248114)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/cc62d4f6-ce2f-4866-9f7c-6fb96e95b6a3.png)]

因此，查看这些评估指标的箱形图，我们看到，随机森林表现最佳。

要检查这些模型的可变程度，我们可以分析回归模型的测试 MSE 的标准差。 以下屏幕截图显示了用于检查变异程度的代码，以及显示了这些模型的标准差的图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mKK7CXZn-1681654248115)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e98e483d-748c-4067-ab99-27a387d6d1c6.png)]

前面的屏幕截图显示，在这种情况下，最多的模型是 KNN 模型，其次是提升模型，而随机森林模型的变化最小。 因此，随机森林模型是这三种模型中最好的。 即使对于此数据集，随机森林模型也表现最佳。

超参数调优简介

用于为特定数据集选择最佳估计量或为所有超参数选择最佳值的方法称为超参数调优。 超参数是无法在估计器中直接学习的参数。 它们的值由建模者决定。

例如，在RandomForestClassifier对象中，有很多超参数，例如n_estimators，max_depth，max_features和min_samples_split。 建模人员确定这些超参数的值。

穷举网格搜索

执行超参数调优的最重要且最常用的方法之一是穷举网格搜索。 这是一种蛮力方法，因为它尝试从参数值网格中尝试所有超参数组合。 然后，对于超参数的每种组合，使用 K 折交叉验证和任何其他指定的指标来评估模型。 因此，为我们提供最佳度量的组合是我们将在scikit-learn中使用的对象返回的组合。

让我们以超参数网格为例。 在这里，我们为n_estimators超参数尝试三个不同的值，例如 10、30 和 50。 我们将为max_features尝试两个选项，例如auto和平方根，并为max_depth分配四个值 -5、10、20 和 30。 因此，在这种情况下，我们将有 24 个超参数组合。 这 24 个将被评估。 在这种情况下，对于这 24 个组合中的每个组合，我们使用十倍交叉验证，计算机将训练和评估 240 个模型。 网格搜索面临的最大缺点是维数的诅咒，这将在以后的章节中介绍。 维数的诅咒从本质上讲意味着，您评估模型的次数将随着参数的数量呈指数增长。

如果未测试某些超参数组合，则可以将不同的网格传递给GridSearchCV对象。 在这里，可以以字典列表的形式传递不同的网格，因为每个网格都是scikit-learn中的字典。

永远不要使用整个数据集来调整参数，在调整参数时始终执行训练测试拆分，否则超参数可能适合该特定数据集，并且该模型不能很好地推广到新数据。

因此，我们执行训练测试拆分，并使用数据集的一部分来学习模型的超参数。 我们留给测试的部分应该用于最终的模型评估，然后我们使用整个数据集来拟合模型。

scikit-learn 中的超参数调优

让我们以diamond数据集为例来了解scikit-learn中的超参数调优。

要执行超参数调优，我们首先必须导入将要使用的库。 要导入库，我们将使用以下代码：

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.metrics import mean_squared_error
%matplotlib inline

然后，我们将转换为在此示例中使用的diamond数据集。 下面显示了用于为此数据集准备数据的代码：

# importing data
data_path= '../data/diamonds.csv'
diamonds = pd.read_csv(data_path)
diamonds = pd.concat([diamonds, pd.get_dummies(diamonds['cut'], prefix='cut', drop_first=True)],axis=1)
diamonds = pd.concat([diamonds, pd.get_dummies(diamonds['color'], prefix='color', drop_first=True)],axis=1)
diamonds = pd.concat([diamonds, pd.get_dummies(diamonds['clarity'], prefix='clarity', drop_first=True)],axis=1)
diamonds.drop(['cut','color','clarity'], axis=1, inplace=True)

准备好数据后，我们将创建用于建模的对象。 下面显示了用于创建建模对象的代码：

from sklearn.preprocessing import RobustScaler
from sklearn.model_selection import train_test_split
target_name = 'price'
robust_scaler = RobustScaler()
X = diamonds.drop('price', axis=1)
X = robust_scaler.fit_transform(X)
y = diamonds[target_name]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=123)

执行并创建用于建模的对象后，我们执行train_test_split函数。 在前面的代码块中，我们将设置 0.1（10%）的数据进行测试，因此在调整超参数后，数据集的这一部分将用于模型评估。

我们将使用以下参数调整RandomForestRegressor模型：

• n_estimators：此参数表示森林中的树木数量。
• max_features：此参数表示寻找最佳分割时要考虑的特征数量。 可能的选择是n_features，它对应于自动超参数，或者是特征数量的log2的平方根。
• max_depth：此参数表示树的最大深度。

这些参数将使用带有网格搜索的不同值。 对于n_estimators和max_depth，我们将使用四个不同的值。 对于n_estimators，我们将使用[25,50,75,100]作为值，对于max_depth，我们将使用[10,15,20,30]作为值。 对于max_features，我们将使用自动和平方根。

现在，我们将在没有任何超参数的情况下显式实例化RandomForestRegressor模型。 下面显示了用于实例化它的代码：

from sklearn.ensemble import RandomForestRegressor
RF = RandomForestRegressor(random_state=55, n_jobs=-1)

参数网格基本上是一个字典，我们在其中传递超参数的名称和我们想要尝试的值。 以下代码块显示了具有不同参数的参数网格：

parameter_grid = {'n_estimators': [25,50,75,100], 
 'max_depth': [10,15,20,30],
 'max_features': ['auto','sqrt']}

总共，n_estimators有四个值，max_depth有四个值，max_features有两个值。 因此，在计算中，总共有 32 个超参数组合。

要在scikit-learn中执行超参数调优，我们将使用GridSearchCV对象。 下面显示了用于从scikit-learn导入对象的代码：

from sklearn.model_selection import GridSearchCV

在这里，我们传递要调整的估计器，在这种情况下为RandomForestRegressor。 以下屏幕截图显示了所使用的代码和我们获得的输出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-21y4KSqO-1681654248115)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/7c374323-bcaa-4d95-b126-082372f965e8.png)]

然后，我们传递要尝试的参数网格。 在这里，refit表示此估计器对象将使用通过网格搜索和交叉验证过程找到的最佳参数进行调整。 这是此对象将用于评估超参数的所有可能组合的评估度量。 在这种情况下，我们将使用十倍交叉验证。 创建完之后，我们可以使用fit方法并传递训练对象。 由于我们使用 32 种组合的十倍交叉验证，因此该模型将评估 320 个模型。

我们可以从使用GridSearchCV方法创建的对象中使用cv _results_属性获得结果。 以下屏幕截图显示了用于获取结果的代码，并显示了结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0CoO69yn-1681654248115)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/1c8cf2ba-e2f8-4301-96d2-f7e29f2876c0.png)]

在这里，最重要的是获得best_params_。 因此，使用best_params_，我们可以看到所有 32 个组合的参数组合。 以下屏幕快照显示了用于获取参数的输入，而输出则显示了可以提供最佳结果的参数组合：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IaPKREnU-1681654248115)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/99ba11ae-8c28-44e3-bebe-433858fbe813.png)]

在这里，我们看到可以给出best_params_的组合是max_depth的值为20，max _features的值为auto和n_estimators的值为100。 因此，这是参数的最佳组合。

我们还可以获取best_estimator_对象，这是超参数的完整列表。 以下屏幕截图显示了用于获取best_estimator_的代码，并显示了结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8l9WIwm8-1681654248115)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/5e34b51a-55e9-4422-a75d-599120926bbf.png)]

因此，当我们调整随机森林模型的超参数时，我们得到的值与之前获得的值不同； 当我们将n_estimators的值设置为50时，将max_depth的值设置为16，将max_features的值设置为auto时，该模型中的参数未调整。

比较已调整和未调整的模型

我们可以将调整参数时获得的最佳模型与我们一直使用的最佳模型进行比较，而无需调整50值，max_depth值16和 max_features作为auto，在两种情况下都是随机森林。 以下代码显示了已调整模型和未调整模型的参数值：

## Random Forests
RF_model1 = RandomForestRegressor(n_estimators=50, max_depth=16, random_state=123, n_jobs=-1)
RF_model1.fit(X_train, y_train)
RF_model1_test_mse = mean_squared_error(y_pred=RF_model1.predict(X_test), y_true=y_test)
## Random Forest with tunned parameters 
RF_tunned_test_mse = mean_squared_error(y_pred=RF_classifier.predict(X_test), y_true=y_test)

要实际查看已调整模型和未调整模型之间的比较，我们可以看到均方误差的值。 以下屏幕截图显示了用于获取两个模型的mean_squared_error值的代码，以及显示了两个模型的 MSE 值的比较的图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fgrfaFPI-1681654248116)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/3bb189e2-3e82-45bc-911a-302a14c799f4.png)]

相比之下，我们可以清楚地观察到，在两个随机森林模型中，这些调整后的参数的表现均优于未调整后的参数。

要查看两个模型之间的实际值差异，我们可以做一些计算。 以下屏幕截图显示了获得改进百分比的计算，并显示了实际百分比值的输出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qApG0P1R-1681654248116)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/de47b18f-6727-4197-8078-2b10a3457512.png)]

在这里，经过调整的模型比未调整的模型提高了 4.6%，这实际上非常好。 在这些模型中，提高 1% -3% 的百分比也可能具有巨大的实际意义。

总结

在本章中，我们学习了交叉验证以及各种交叉验证方法，包括保留交叉验证和 k 折交叉验证。 我们知道 k 折交叉验证不过是多次进行保留交叉验证而已。 我们使用diamond数据集实现了 k 折交叉验证。 我们还使用 K 折交叉验证比较了不同的模型，并找到了表现最佳的模型，即随机森林模型。

然后，我们讨论了超参数调优。 我们遇到了详尽的网格搜索方法，该方法用于执行超参数调优。 我们再次使用diamond数据集实现了超参数调优。 我们还比较了调整后的模型和未调整的模型，发现调整后的参数使模型的表现优于未调整的模型。

在下一章中，我们将研究特征选择方法，降维和主成分分析（PCA）以及特征工程。 我们还将学习一种通过特征工程改进模型的方法。

三、使用特征

在本章中，我们将仔细研究特征如何在特征工程技术中发挥重要作用。 我们将学习一些技术，这些技术将使我们能够通过两种方式改进预测分析模型：就模型的表现指标而言，以及了解特征与我们试图预测的目标变量之间的关系。

在本章中，我们将涵盖以下主题：

• 特征选择方法
• 降维和 PCA
• 创建新特征
• 通过特征工程改进模型

特征选择方法

特征选择方法用于选择可能有助于预测的特征。 以下是三种特征选择方法：

• 删除低方差的虚拟特征
• 通过统计确定重要特征
• 递归特征消除

在建立预测分析模型时，某些特征将与目标无关，这将对预测没有太大帮助。 现在的问题是，在模型中包含不相关的特征会引入噪声并给模型增加偏差。 因此，特征选择技术是用于选择最相关和最有用的特征的一组技术，这些特征将有助于预测或理解我们的模型。

删除低方差的虚拟特征

我们将学习的特征选择的第一种技术是删除方差低的虚拟特征。 到目前为止，我们一直在对特征进行的唯一转换是使用编码技术对分类特征进行转换。 如果我们采用一个分类特征并使用此编码技术，则会得到一组伪特征，将对其进行检查以查看它们是否具有可变性。 因此，方差非常低的特征可能对预测影响很小。 现在，为什么呢？ 假设您有一个具有性别特征的数据集，而 98% 的观测值仅对应于女性。 此特征不会对预测产生任何影响，因为几乎所有情况都属于一个类别，因此变异性不足。 这些案例成为排定要消除的候选对象，应该更仔细地检查这些特征。 现在，看看以下公式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S7waOiT6-1681654248116)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/5fc96b69-e4fa-497c-9c96-25fc7005239d.png)]

您可以删除超过x%的样本中所有为 0 或 1 的虚拟特征，或者可以为这些特征的方差建立最小阈值。 现在，可以使用前面的公式获得这些特征的方差，其中p是您的虚拟特征中1的数量或比例。 我们将在 Jupyter 笔记本中查看其工作原理。

通过统计确定重要特征

此方法将帮助您利用一些统计测试来识别和选择相关特征。 因此，例如，对于分类任务，我们可以使用 ANOVA F 统计量来评估数字特征和目标之间的关系，这将是分类特征，因为这是经典任务的一个示例。 或者，为了评估分类特征与目标之间的统计关系，我们将使用卡方检验来评估这种关系。 在scikit-learn中，我们可以使用SelectKBest对象，我们将在 Jupyter 笔记本中了解如何使用这些对象。

递归特征消除

识别重要特征并删除我们认为对模型不重要的特征的过程称为递归特征消除（RFE）。 RFE 也可以应用在scikit-learn中，我们可以使用此技术来计算系数，例如线性，逻辑回归，或使用模型来计算特征重要性。 随机森林模型为我们提供了这些特征重要性指标。 因此，对于既不计算系数也不计算特征重要性的模型，则无法使用这些方法。 例如，对于 KNN 模型，您不能应用 RFE 技术，因为这首先要预先定义要在模型中使用的特征。 使用所有特征，此方法将拟合模型，然后基于系数或特征重要性，消除最不重要的特征。 在所选的一组特征上递归地重复此过程，直到最终达到所需的要选择的特征数量。

有以下几种方法可以选择模型中的重要特征：

• L1 特征
• 选择阈值方法
• 基于树的方法

让我们转到 Jupyter 笔记本，看看我们如何在scikit-learn中实际应用这些方法。 以下屏幕快照描述了导入所需的库和模块：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6gLX7mvj-1681654248116)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/d000765a-0b4c-4f0a-8728-f5099e1253e0.png)]

在以下屏幕截图中，我们首先使用了信用卡默认数据集，并且将对原始数据进行的传统转换应用于：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-noqKmQ8q-1681654248116)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/9f819808-eb10-415a-932d-7e3ea519fb41.png)]

以下屏幕快照显示了数据集中具有的虚拟特征和数值特征，具体取决于特征的类型：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8n9GHft2-1681654248117)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/4060697e-b56b-42ff-a373-fba66f231307.png)]

在这里，我们将缩放操作应用于特征建模：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yeTRbrcm-1681654248117)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/89e9ea9d-aabf-4dc1-9df0-c8b36d6e2b98.png)]

我们在演示中讨论的第一种方法是使用var()方法删除具有低方差的伪特征以从我们的特征中获得方差：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S2UEBa3B-1681654248117)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/9f9a3dae-0abb-442a-a84e-06eee184e9e1.png)]

让我们只看一下虚拟特征的变化； 例如，方差的阈值将仅考虑方差超过0.1的虚拟特征。 在这种情况下，以 0.1 为阈值，将消除的两个候选候选pay_5和pay_6是将被删除的前几个具有低方差的不必要虚拟特征。 请看以下屏幕截图，该屏幕截图描绘了要淘汰的候选人：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-06SFA7ST-1681654248117)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/36866649-2516-4eca-b8ec-7d2e8624cf8f.png)]

我们讨论的第二种方法是从统计角度选择与目标相关的特征，并且有两种情况，虚拟特征和数值特征。

让我们对虚拟特征进行统计测试。 我们将从scikit-learn库中feature_selection模块中的chi2对象中导入对象。 我们还将使用SelectKBest对象在所有虚拟特征中执行统计测试，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vyhz7AYN-1681654248117)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/22827f00-aeb2-41ce-8d4f-7fa9e1b74377.png)]

在这里，我们实例化一个名为dummy _selector的对象并通过所需的统计测试以应用于该对象。 在这里，我们通过了k ="all"参数，因为此统计测试将应用于所有虚拟特征。 实例化此对象后，将调用fit()方法。 看一下以下屏幕截图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UtT9CpTi-1681654248118)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/fb58b92b-6578-4731-9691-e36707a4aca6.png)]

在以下屏幕截图中，我们具有卡方得分。 这不是一项统计测试，数字越大，特征与目标之间的关系越强：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VjU1Zv7o-1681654248118)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/9a4ab20a-c9c9-447b-99b6-e9127829ea6f.png)]

现在，如果您还记得统计课，这就是假设检验设置。 因此，我们还可以计算 p 值，可以说pvalues_大于0.05的特征与目标无关。 现在，在这种情况下，所有特征的 p 值都非常小，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AiJdh1Ip-1681654248118)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/a45bc992-e373-4029-a504-a3a1cab481d5.png)]

目标和所有虚拟特征之间都有关系，因此在这种方法下，我们不应消除任何这些虚拟特征。

现在，我们可以使用另一个名为f_ classif的统计测试来评估数字特征与目标之间的关系，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gSUXDjX3-1681654248118)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/a383b1d7-db46-402f-8685-561a59bb9efe.png)]

重用此f_classif对象，我们将通过所需的统计测试和特征数量。 在这种情况下，我们想将测试应用于所有数值特征，然后对数值特征和目标再次使用fit()方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gya7Ygcw-1681654248118)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/7d176673-5b2a-4baf-bcca-c02a1d8d8d1c.png)]

以下屏幕快照显示了我们从此统计测试的应用收到的 p 值：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cz6xcOI6-1681654248119)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/1f7a09ea-105f-424e-8e4c-9c4887a7ced9.png)]

我们可以通过f_classif统计检验，然后选择 p 值大于0.05的数值特征，这是统计检验的常用阈值； 此处产生的特征是bill_amt4，bill_amt5和bill_amt6，它们可能与目标无关或无关：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-48udId8I-1681654248119)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/1d128d68-8142-47e4-b6d0-95982e12dc43.png)]

我们有 3 个可以消除或可以应用的消除候选者。 我们在前面的步骤中使用了第二种技术，现在在以下部分中将使用第三种技术。

RFE 是我们将使用RandomForestClassifier模型的第三种技术，请记住这里有 25 个特征：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oy1su8rA-1681654248119)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/ccc37681-6a78-4244-ac36-8cef9d4360ee.png)]

因此，假设我们只选择 12 个特征，而我们想要一个仅使用 12 个特征的模型。 因此，我们使用了大约一半的特征。 我们可以使用feature_selection模块中scikit-learn中存在的RFE对象。 我们可以使用 RFE 技术使用它来实际选择这 12 个特征。 因此，我们通过传递所需的估计量和要选择的特征数量来实例化此对象：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eFzGKSAV-1681654248119)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/515cf59d-8bc9-428d-99ee-c0693af054cc.png)]

现在，请记住，随机森林为我们提供了特征重要性的度量标准，可以与 RFE 技术一起使用：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iAV2mgwS-1681654248119)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/7c041ba0-ebbf-4f72-acb1-331a690b14fe.png)]

在整个数据集上使用fit()方法后，我们获得了recursive_selector.support_和True包含在模型中的特征，所需的 12 个特征，并获得了False表示应删除的特征。 ：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MYvpPfDD-1681654248120)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/316a9ba5-01e9-4406-b46e-7f3db0970ea8.png)]

因此，根据此目标和方法，我们应该在随机森林模型中包含 12 个最重要的特征，以便预测诸如limit_bal，age，pay之类的目标; 所有账单金额； 和pay_amt1，pay_amt2和pay_amt3，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XVEvwap1-1681654248120)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/dc1ad6e3-8378-4971-b073-ec6ffe1631a1.png)]

这些是应消除的特征，因为根据此方法和用于预测目标的模型，它们并不十分相关：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7zL9Ai1V-1681654248120)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/a290e198-14e2-4776-aa59-c31137a3b76c.png)]

现在，我们可以评估较简单的模型，该模型具有 12 个特征，而到目前为止我们一直在使用完整模型，之后，我们可以使用交叉验证来计算指标。 因此，在此示例中，我们使用 10 倍交叉验证来评估这两个模型的表现。 请记住，根据 RFE 技术，此选择器模型是完整模型，结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Njc0dAnR-1681654248120)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c19b384c-506d-4e42-85bc-8cfe711c1e3f.png)]

完整模型的召回度为0.361365，仅包含 12 个特征的模型的召回度为0.355791。 由于此模型的召回率较低，因此完整模型仍然是最佳模型。 但是，如果我们使用其中一半特征，则完整模型也会为我们提供类似的表现：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HuaLGuqQ-1681654248120)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/a2f3dcbb-fedd-4e46-b2e9-3a4d52135093.png)]

正如您在以下屏幕截图中所看到的，这些值确实很接近：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BZYp0ih9-1681654248120)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/d85e222b-999c-40d8-bf81-05b389a3b7c6.png)]

现在，您可以决定是要使用完整模型还是要使用简单模型。 这取决于您，但是就准确率而言，我们几乎可以达到相同的水平，尽管整个模型的准确率仍然更高：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3qQzDqTR-1681654248121)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/de3fc718-3686-4136-a8e3-b483cdfa8f62.png)]

现在，您可以使用一种技术来决定要使用具有更多特征的更复杂模型还是更简单的模型。

降维和 PCA

降维方法是通过获取一组主变量来减少所考虑特征数量的过程。 主成分分析（PCA）技术是用于降维的最重要技术。 在这里，我们将讨论为什么需要降维，并且还将在scikit-learn中看到如何执行 PCA 技术。

这些是在进行预测分析时拥有大量特征的原因：

• 它可以简化模型，从而使模型更易于理解和解释。 如果要处理成千上万的特征，可能需要一些计算方面的考虑。 减少特征部件数量以节省计算资源可能是一个好主意。
• 另一个原因是要避免“维度诅咒”。 现在，这是一个技术术语，在处理高维数据时会出现一系列问题。
• 这也有助于我们最大程度地减少过拟合，因为如果您包含许多不相关的特征来预测目标，则您的模型可能会过拟合该噪声。 因此，删除不相关的特征将帮助您进行过拟合。

在本章前面看到的特征选择可以认为是降维的一种形式。 当您具有一组紧密相关甚至冗余的特征时，PCA 将是使用较少特征对相同信息进行编码的首选技术。 那么，什么是 PCA？ 这是一种统计过程，将一组可能相关的变量的观测值转换为一组线性无关的变量，称为主成分。 我们不要讨论有关 PCA 发生了什么的数学细节。

假设我们有一个二维数据集。 PCA 确定数据集变化最大的方向，并将关于这两个特征的最大信息量编码为一个特征，以将维数从二维减少为一个。 此方法将每个点投影到这些轴或新大小上。

如下面的屏幕截图所示，这两个特征的第一个主要组成部分是点到红线上的投影，这是 PCA 中发生的事情的主要数学直觉：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TCDnjVkT-1681654248121)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/941fd408-2576-441e-b2eb-37e2ea9a84fa.png)]

现在，让我们转到 Jupyter 笔记本，看看如何实现降维方法并将 PCA 应用于给定的数据集：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iosVqLNY-1681654248121)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/0029c5de-ae04-47d1-b311-e42d0d1bff40.png)]

在这种情况下，我们将使用信用卡默认数据集。 因此，在这里，我们正在做到目前为止介绍的转换：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TMmFthut-1681654248121)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c5fd83e2-cab0-468d-af4d-1270ef9b3656.png)]

现在，让我们看一下帐单金额特征。 我们具有以下六个特征，这些特征与一到六个月前的账单金额历史密切相关，正如您从以下代码片段屏幕截图生成的可视化效果中可以看到的那样：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F6fo4aln-1681654248121)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/360ba160-c0a2-457e-9435-abe501b4c447.png)]

因此，它们表示相同的信息。 如果您看到客户在两三个月前的账单金额很高，那么很可能他们一个月前的账单金额也很高。 因此，正如您从以下屏幕快照所示的可视化效果中看到的那样，这些特征确实紧密相关：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sdrHxRdq-1681654248122)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/11d8b84c-f9c7-4cb8-a6d2-8bea6e03ad7e.png)]

我们通过计算相关系数来确认这一点。 如您所见，它们之间确实具有高度相关性：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f1Jp4FrR-1681654248122)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c8a4f728-6e65-43d6-887f-331d841c3298.png)]

一个月前和两个月前的账单金额之间的相关性是0.95。 我们具有很高的相关性，这是应用降维技术的好机会，例如scikit-learn中的 PCA，我们从sklearn.decomposition导入了降维技术，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aWdbLB4t-1681654248122)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/14f1e55c-9574-4e3f-a89e-902ba51eb556.png)]

之后，我们实例化此PCA对象。 然后，我们将要应用 PCA 分解的列或特征传递给：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oK6fJzKD-1681654248122)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/f4998794-1b14-4646-83ca-ab9e871a4de8.png)]

因此，在使用从该对象派生的fit()方法之后，我们接收到其中一个属性，即解释的方差比，如以下屏幕快照所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pREBYxBB-1681654248123)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/b99b1080-769c-40c4-8c7f-23e63fe9adbd.png)]

让我们绘制此数量，以了解这些特征的运行情况。 如您所见，我们得到了所有六个组成部分的解释方差：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UVxxRAel-1681654248123)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e63ef069-1047-4913-b7d1-396f817af0df.png)]

读取此图的方式是，我们在这六个特征上执行的 PCA 的第一部分编码了所有六个特征的总方差的 90% 以上。 第二个变量的变化很小，而第三，第四，第五和第六个分量的变化也很小。

现在，我们可以在以下屏幕快照中所示的累积解释方差图中看到这一点：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EXSUEF28-1681654248123)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/ef93a131-19d8-4ce0-b10e-698b21ef1cfa.png)]

如您所见，第一个组件编码了我们使用的六个特征的 90% 以上的方差。 因此，仅一项特征就可以获取 90% 以上的信息。 因此，您可以仅使用一个特征而不是使用六个特征，而仍然获得 90% 以上的方差。 或者，您可以使用前两个组件，并仅通过两个特征（此 PCA 的第一和第二个组件）获得六个特征所包含的全部信息的 95% 以上。 因此，这就是实践中的工作方式，我们可以将其用作执行特征工程的一种技术。

特征工程

特征工程在使机器学习算法正常工作中起着至关重要的作用，如果正确执行，它会增强机器学习算法的预测能力。 换句话说，特征工程是使用领域知识，问题的上下文或产生更准确的预测模型的专门技术，从原始数据中提取现有特征或创建新特征的过程。 这是一项领域知识和创造力起着非常重要作用的活动。 这是一个重要的过程，可以显着提高我们的预测模型的表现。 您对问题的了解越多，创建新的有用特征的能力就越强。 基本上，特征工程过程会将特征转换为算法可以理解的输入值。

有多种实现特征工程的方法。 您可能会发现所有技术都不可行，并且最终可能会排除其中的一些技术。 这样做的目的不是要就此主题进行学术讨论，而是要向您展示在使用特征和尝试创建新特征时我们所做的一些常见操作。 第一个是缩放特征，用于将其范围转换为更合适的特征。 另一个是以更好的方式对信息进行编码，我们将在本章后面看到一个示例。 特征工程涉及从现有特征创建新特征，以便您可以通过对现有特征执行一些数学运算来组合它们。

创建新特征的另一种方法是使用降维技术，例如我们之前看到的 PCA。 只要您使它具有创造力，使用哪种技术都没有关系。 如前所述，您对问题的了解越多越好。

创建新特征

我们将在此处使用信用卡默认值和钻石数据集。 现在，让我们转到 Jupyter 笔记本创建新特征，并了解这些技术在实践中的用途：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JX87Sm5Q-1681654248123)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/1f149084-6127-4ec7-be75-0550b89c0895.png)]

让我们通过执行一些命令来导入信用卡默认数据集，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FrcaRr0g-1681654248123)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/2fcfac44-86fd-447e-a414-866ba15d6164.png)]

我们将要做的第一个转换是创建另一种方式来编码education函数中的信息。 到目前为止，我们已经在education函数中使用了一种编码技术，并且我们将使用x变量的上下文来提出另一种编码。 受过研究生教育的人比受过其他教育的人受过更高的教育。 因此，我们可以针对这些特征提出某种积分系统。 例如，我们可以为受过高等教育的人分配 2 分，为受过大学教育的人分配 1 分，而为该数据集中的其他教育水平分配负分。

让我们看一下以下屏幕截图，看看如何完成此操作：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P1sU5673-1681654248124)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c0580fcd-23d3-41a8-b5e1-9ec4978e0dd3.png)]

前面的屏幕快照反映了我们在这些教育级别中的顺序，因此这可能是编码信息的另一种方法。 这在预测下个月的默认值方面可能有帮助，也可能没有帮助。 但是，我们可以尝试使用这项新技术对信息进行编码，并在以下屏幕截图中查看结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1iOpaZNW-1681654248124)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/be40f9c7-3a02-4f08-a59f-befb73a3a7c0.png)]

我们可以在此数据集中使用的另一种技术是在此问题的背景下使用账单金额和付款金额特征来计算这两个变量/特征之间的差异。 因此，如果我们从特定月份中提取帐单金额，然后减去该月份的付款金额，我们将获得一定数量或数量。 在此示例中，我们调用bill_minus_pay变量，该变量代表客户针对该月的账单付款。 因此，此新得出的数量可用于预测下个月的违约者。 我们已将它们包含在此数据集的潜在预测模型中：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xidgjhGN-1681654248124)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/1275ad80-b856-4812-ac04-b562ac2fc4a7.png)]

现在，让我们看一下以下输出，该输出描述了特定月份的默认值：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WyCpIQvU-1681654248124)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/7a5678a6-7c8b-4658-9c06-d20905e46e44.png)]

我们现在可以在这里使用的另一种方法是，现在我们在名为bill_minus_pay的新特征中拥有了这些特征的部分信息，那就是我们可以使用以下特征仅汇总一个屏幕快照中显示的六个特征的主要信息： PCA 技术：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zj83GHCG-1681654248124)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/fbf447a5-af00-402d-8bb9-b5c0d34cb41d.png)]

我们可以使用付费特征执行相同的操作。 从先前的分析中，我们知道pay_1函数对于预测接下来要付款的人非常重要。 因此，为了将其他五个pay_i函数减少到两个，我们将六个账单金额特征减少到一个，并将六个pay_i函数减少到两个。 除此之外，我们再次对其余五个pay_i函数应用 PCA 技术，以将这五个特征减少到仅一个。 看一下以下屏幕截图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wWP7UTQc-1681654248125)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/3b49bf31-73fe-48a7-9e42-dc69ef617e7e.png)]

这些是一些特征工程技术以及示例，您可以在数据集中执行这些示例，但是您可能希望从现有转换中创建其他转换或变量。

现在，让我们看一下钻石数据集中的几个示例。 我们需要通过执行一些命令来导入钻石数据集，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4m6rgdWf-1681654248125)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/1a5b38e2-d2e8-4ed0-b02e-add5805bddac.png)]

如前面的屏幕截图所示，我们已经使用编码技术对一些分类特征进行了转换。 现在，让我们看一下导入的数据集，如以下屏幕快照所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3a7K9nEe-1681654248125)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/fa90eb24-2ac3-4ab2-8541-8e645dc22c8b.png)]

这就是我们具有四个特征[散布图矩阵]的散布图矩阵x，y，z和price的样子。 前三个特征指的是钻石的大小，price表示这三个特征与钻石的定价之间的关系：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Atjq8jn-1681654248125)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/050dd302-e6ac-4f0e-a5e2-d12c18a1ec60.png)]

如您所见，在前面的屏幕截图中，前三个特征之间有非常强的线性关系，这是此散点图矩阵中有趣的事情之一。

由于钻石是三维物体，因此我们将这三个特征组合为一个称为体积的特征。

现在，我们将乘以x，y和z轴的测量值，这将得出一个接近该对象体积的数字：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2qSOgYse-1681654248125)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/d50740ee-536d-4157-bc16-bd22cdc23c3c.png)]

现在，我们知道它们不是盒子，并且它们没有任何固定的形状。 但是，这将是钻石体积的非常好的近似值。 因此，这可能是我们可以从此数据集中现有特征创建新特征量的另一种方法。

在下一个屏幕截图中，我们具有对象的体积以及钻石的重量，其度量为carat，我们将使用它们来创建一个名为density的新特征：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L2mfxFOO-1681654248126)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/3af98542-6143-49f9-97c4-1b739b8fe2f1.png)]

如您在前面的屏幕快照中所见，我们将克拉数除以体积，以获得钻石对象的密度。

这就是我们从给定的上下文中创建两个特征的方式，这证明了该陈述的正确性：“问题的知识或上下文越多越好”。 如您所见，仅通过提供的有关问题的知识，我们就可以提出新特征。

现在，让我们尝试看看这些特征可能对预测模型有多大帮助。 我们将在这里使用的示例是如何组合现有特征以产生新特征。 下图显示了数量和价格之间的紧密关系：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NpN5cEiV-1681654248126)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/b91bb49e-1916-444c-9476-2e49dd2d06cb.png)]

我们可以假设数量将有助于预测价格。

但是，在下面的密度和价格散点图中，我们看到所有钻石都具有相同的预期密度：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0fKSXBl6-1681654248126)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c4374d52-538a-45a8-841e-ef21e716744d.png)]

当我们看到已经存在的price和carat之间的相关性时，似乎density可能与price无关：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VTGwyz1Q-1681654248126)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/939ece93-e875-418f-b250-fa4e70de9f2a.png)]

因此，此新特征可能对预测没有太大帮助。 体积和克拉特征具有相同的关系。 我们可能无法利用此特征获得很多预测能力，但是解释此示例的主要目的是展示如何组合数据集中已有的不同特征以创建新特征。

这就是特征工程的全部意义。 您可能还会想到此数据集的其他特征。

通过特征工程改进模型

现在，我们已经了解了特征工程技术如何帮助构建预测模型，让我们尝试改善这些模型的表现，并评估新构建的模型是否比先前构建的模型更好地工作。 然后，我们将讨论在进行预测分析时必须始终牢记的两个非常重要的概念，它们是预测模型中可减少和不可减少的误差。

首先导入所需的模块，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UNKrWthl-1681654248126)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/d9b2c9df-4eeb-4402-82d7-a47930ea0880.png)]

因此，让我们转到 Jupyter 笔记本，看看在本章前面看到的导入的信用卡默认数据集，但是正如您所看到的，已经对该数据集进行了一些修改：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rG3gl60C-1681654248127)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/18835e99-b7bb-4d75-bc85-c5ff4582984f.png)]

对于该模型，我们没有使用male和married来将sex和marriage特征转换为两个虚拟特征； 因此，让我们以略有不同的方式对信息进行编码，以查看效果是否更好。 因此，我们将信息编码为married_male和not_married_female，然后看效果是否更好。 这是我们在这里进行的第一个转换。 这是数据集的样子：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GBar5QGO-1681654248127)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/a9782f93-7ebb-4755-89b9-1a18495aad5c.png)]

现在，让我们做更多的特征设计。 我们要做的第一件事是计算这些新特征，这些新特征是通过从账单金额中减去付款金额而构建的，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-obqIGtwZ-1681654248127)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/a543d2e0-8351-4c63-b35c-e118875fb5b4.png)]

对于这个问题，我们将执行一个数学运算。 我们将使用前面截图中显示的新特征来预测目标。 现在，帐单金额特征中的大多数信息都已编码为这些特征，不再需要，但是我们可以使用 PCA 技术将六个帐单金额特征减少为一个，而不是丢弃它们。 因此，让我们应用 PCA 技术将六个特征简化为一个组件。 现在有一个名为bill_amt_new_feat的新特征。 因此，这是我们执行的第二个特征工程步骤。 最后，对于pay_i函数，我们将按原样保留第一个特征，并将 PCA 技术应用于后五个函数pay_2，pay_3，pay_4，pay_5和pay_6， 将这五个特征简化为仅两个组成部分。 您可以在PCA对象上使用fit_transform方法来获取组件。

现在，让我们看下面的屏幕快照，显示所有与金钱有关的特征。 如您所见，这里的差异确实很大，因为货币金额很大：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LzH74hEq-1681654248127)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/d9405c76-fd54-48c7-bb70-94af065be775.png)]

现在，通过将它们除以 1,000 来重新缩放这些特征，以减小差异，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mcSlYauD-1681654248127)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/3ef1e002-540e-4c2b-8e7a-858c96a183b0.png)]

这有助于我们使这些数字易于理解。 因此，这是我们所做的另一种转换，现在让我们使用这些新特征来训练我们的模型。

训练模型

以下模型是新模块，因为与其他模型相比，它具有不同的特征。 由于特征已更改，因此我们需要使用GridSearchCV模块为RandomForestClassifier模块找到最佳的超参数。 因此，也许以前找到的最佳参数并不是这些新特征的最佳参数。 因此，我们将再次运行GridSearchCV算法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iMahuuqa-1681654248128)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/7e2ac386-5dc1-4970-b04a-44456a49da23.png)]

如以下屏幕截图所示，在这种情况下，这些新特征的最佳参数组合是30的max _depth，auto中的max_features和n_estimators（估计数）应为100 ：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vNDnMwF3-1681654248128)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/b4892e44-1011-4f54-9605-577ce1933e06.png)]

现在，让我们评估一下我们使用特征工程构建的新模型，并将其与先前从先前构建的模型中获得的指标进行比较：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wudu9w0W-1681654248128)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/af57d7ee-8abb-400f-b988-7d53e42ed206.png)]

如您在前面的屏幕截图中所见，我们使用的阈值为 0.2。 该模型生成71.39% 的召回率和37.38的精度。 在这里，精度是相似的，但是，如前所述，召回率可能是我们应该关注的指标，因为与前一个指标略有不同。 我们对该模型有更好的回忆。 更改可能只是 2% 或 3%，看起来似乎并不多，但是请记住，在这些财务应用中，实际上提高 1% 或 2% 可能意味着很多钱。 因此，使用这种小特征工程技术，我们对模型的预测能力有了一点改进。 让我们在以下屏幕截图中查看特征的重要性：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-57ASmtCg-1681654248128)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/9225a3eb-041c-46f0-bc51-d6724b30d4f0.png)]

您可以在以下随机森林模型的屏幕截图中评估此特征的重要性是否有意义：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pk8CPqRL-1681654248128)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/6062dd52-525e-48e5-90ed-caa3e760dbe1.png)]

您可以将此特征的重要性与之前的特征进行比较。 应用特征工程后，您可以做很多事情。 我们可能会提高表现并从模型中获得见识。 已经观察到，通过使用此技术，我们对模型进行了一些改进。 现在，您可以提出不同的方法来组合现有特征，以进一步改善模型。 这只是一个简单的小例子，向您展示您可以实际使用有意义的特征来玩这些特征。

可减少和不可减少的误差

在继续进行之前，预测分析要涵盖两个非常重要的概念。 误差可以分为以下两种类型：

• 可减少的误差：可以通过对模型进行某些改进来减少这些误差
• 无法减少的误差：完全无法减少这些误差

假设在机器学习中，特征与目标之间存在由函数表示的关系，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lLb7MadM-1681654248129)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/4dcab463-bc46-4047-9f46-8d6b362ce700.png)]

假设目标（y）是机器学习的基础假设，并且特征与目标之间的关系由一个函数给出。 由于在大多数情况下，我们认为特征与目标之间的关系存在一定的随机性，因此我们在此处添加了一个噪声项，该噪声项将始终存在于现实中。 这是机器学习中的基本假设。

在模型中，我们尝试在执行特征工程，调整参数等时通过使用实际函数来近似理论函数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q6rRn3jp-1681654248129)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/86502f63-aa51-40f7-8605-e6feaecaf2c3.png)]

因此，我们的预测是将这些近似值应用于概念或理论f的结果。 我们在机器学习中所做的所有事情都是通过训练模型来尝试近似f函数。

训练模型意味着近似该函数。 可以从数学上显示预期误差（可以定义为实际y与预测的y之差）可以分解为两个项。 一个术语称为可减少的误差，另一术语称为不可减少的误差，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7bMkM1uj-1681654248129)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/ba4c0671-5d52-4204-806c-85b9c4ecfcd9.png)]

现在，不可减少的误差项是该随机项的方差。 您对此词没有任何控制权。 总会有一个不可减少的误差成分。 因此，您的模型总是会出错； 无论您拥有多少个特征和数据点，您的模型都不能总是 100% 正确的。 我们必须尝试使用更好和更复杂的方法来执行特征工程，并尝试将我们的估计近似为真实函数。 仅仅因为您使用的是更复杂的模型或您有更多的数据，您的模型就不会是完美的，并且您将无法准确预测y是什么，因为几乎所有过程都存在需要处理的随机性。 这是一个非常有趣的部分的结尾。

总结

在本章中，我们讨论了特征选择方法，如何区分有用的特征和对预测没有帮助的特征。 我们讨论了降维，并学习了如何在scikit-learn中执行 PCA。 我们还讨论了特征工程，并尝试在迄今为止一直在使用的数据集中提出新特征。 最后，我们尝试通过提供新特征以及使用本章学到的所有技术来改进信用卡模型。 希望您喜欢本章。

在下一章中，我们将学习人工神经网络以及在使用神经网络和人工智能时如何使用tensorflow库。

四、人工神经网络和 TensorFlow 简介

在本章中，我们将介绍人工神经网络（ANN），它们基本上是受活脑和感知器启发的计算模型，而感知器是 ANN 的基础。 我们还将讨论构建深度神经网络模型时要考虑的所有特征。 然后，我们将讨论 TensorFlow，这是我们将用来创建这些深度神经网络模型的库。 最后，我们将讨论我们需要了解的有关 TensorFlow 的核心概念，以便使用这些库概念，例如变量，占位符，会话，图以及其他对于使用此库必不可少的概念。

以下是随着我们的前进将涉及的主题：

• 人工神经网络简介
• 深度神经网络的元素
• TensorFlow 的安装和介绍
• TensorFlow 的核心概念

人工神经网络简介

人工神经网络是受生物学启发的计算模型，可用于训练计算机使用数据执行任务。 这些模型是机器学习模型的广泛类别的一部分。 这些模型与其他模型之间的区别在于，这些模型基于称为人工神经元的连接单元的集合。

人工神经网络的类型很多，在本书中，我们将使用一种特定的类型，称为多层感知器（MLP）。 请注意，人工神经网络的变化更多。 这些是机器学习模型，我们可以将它们用于分类和回归任务，但实际上，我们可以扩展这些模型，并将其应用于其他非常特定的任务，例如计算机视觉，语音识别和机器翻译。 这些模型是令人兴奋且不断发展的深度学习领域的基础，在过去的几年中，它在许多领域都取得了成功。

感知器

感知器是最简单的人工神经元类型，被发明为二分类的简单模型。 让我们使用本书中一直使用的数据集（信用卡数据集）的上下文。 假设我们只有两个特征可以对违约者和非违约者进行分类：账龄和账单金额。 因此，感知器的想法是创建某种分数。 为此，将一个常数w1乘以age的值，然后添加另一个常数w2，再乘以bill的值，如下所示：

score = w1age+w2bill

通常，如果score > b，我们将此人归为默认人。

因此，通过这个简单的操作，我们创建了一个分数。 然后，我们遵循规则将人员分类为违约者或非违约者。 因此，如果此score大于某个数字，则我们将此人分类为默认人。

以下屏幕快照显示了一种等效的声明此规则的方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MIq3NleV-1681654248129)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/ee8e1fff-8952-4989-b6ff-f3a0dda854dd.png)]

因此，如果数量大于0，则此模型的预测将为1或默认值；如果数量小于或等于0，则此模型的预测将为0或非默认值。 。 b值也称为阈值或偏差。

通常，如果我们具有n个特征，那么我们的感知器将类似于以下屏幕截图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8xOb6IJm-1681654248129)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/7938be7f-8c64-4cdd-9d93-b6ba65e4d5a6.png)]

如您所见，我们有相同的表格。 如果权重之和乘以特征-b的值实际上大于0，则我们预测1，否则，我们预测0。 假设所有特征都在同一尺度上，权重将代表每个特征在做出决策时的重要性。 因此，我们知道对于这个特殊问题，所有特征的比例都非常不同。 例如，年龄与帐单金额的比例不同，但是假设您将所有特征设置为相似的比例。 您可以将w变量视为权重，它们是决策时每个特征最重要的部分。

以下屏幕截图显示了可视化此感知器的另一种方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u4oWndOR-1681654248130)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/bd6b7f5e-ef5e-4f6e-aac0-a65a57a01b6b.png)]

因此，您具有阈值或偏差b的值，并且具有年龄，x1和帐单金额，x2。 因此，这三个值进入一个运算，然后得到输出。 现在，我们可以对感知器进行一些修改，这就是添加所谓的激活函数。 激活函数是任何可以获取运算结果并使用f函数对输入值进行某种转换的函数。 因此，激活函数的输入是来自运算的结果数量，然后在应用激活函数f之后，我们将获得以下输出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EjS6DlAe-1681654248130)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/b2e13ce5-8226-4536-a9c6-c425619c50d0.png)]

因此，这是感知器。 我们可以向感知器添加激活函数，然后获得规则或分类1或0。

现在，也许您想知道我们如何确定感知器的最佳权重和阈值？ 我们可以使用什么激活函数？ 这些问题的答案由感知器学习算法提供。 因此，有一种学习算法可用于实际训练感知器。 感知器的好处是它们很容易理解。 但是，与更复杂的方法（例如我们在前几章中使用的方法）相比，它们的表现非常弱。 因此，实际上不值得学习这种感知器学习算法。 但是，这些非常简单的模型是人工神经网络的基础。

多层感知器

人工神经网络是基于感知器或其他类似基本构建模块的模型，我们将在本书中学习的模型基于感知器。 MLP 是最受欢迎的 ANN 模型之一，我们将在本书中使用它。 在人工神经网络中使用感知器的动机是，如果不使用一个感知器进行分类，那么如果我们使用其中的许多感知器，会怎样呢？ 看一下以下屏幕截图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0jgZuQBS-1681654248130)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/6f03b677-a86e-4f32-b98d-7818a77e2a6f.png)]

在这里，我们有三个感知器，我们注意到每个感知器都有不同的偏差。 但是在所有情况下，我们特征的值都是相同的。 如果我们使用三个感知器，我们将获得三个输出值，但是我们知道这是一个二分类问题，因此我们仅需要一个输出。 因此，现在我们有了三个输出值，我们可以将它们组合起来，或者可以将这些输出值视为另一个感知器的输入值。 看一下以下屏幕截图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qp8sgsgg-1681654248130)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/8a52b180-965c-47c4-993d-f34100c6e829.png)]

如下面的屏幕快照所示，我们可以将之前的感知器的输出值用作另一个感知器的输入值，而该感知器将为我们提供输出。 因此，这是关于如何构建神经网络或 MLP 的直觉，这是 ANN 的示例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qPQmFYc2-1681654248130)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/9d89276a-5c73-444d-a881-a2659c7699bc.png)]

在前面的屏幕截图中，我们具有以下三个 MLP 层：

• 输入层：在这一层中，您将拥有用于训练此模型的原始数据或训练数据
• 隐藏层：此中间层是前一个感知器的输出，用作下一个感知器的输入
• 输出层：在这一层中，您将获得从网络获得的输出

以下屏幕截图是可视化相同 ANN 的另一种方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RcCP6GKe-1681654248131)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/d0c4a68a-1a43-4bc2-96a2-719ca85c0389.png)]

这是一种更紧凑的可视化方式，但实际上是同一网络。 因此，我们为每个观察结果添加了一个不变的特征1，而不是具有三个偏差。1的值乘以不同的偏差，并作为对我们隐藏层中神经元的输入。x1的值乘以一定的权重，并作为下一个神经元的输入，x2的值也是如此。 然后，将隐藏层中神经元的结果用作我们网络中最后一个感知器的输入，这是总输出。

深度神经网络模型的元素

深度神经网络（DNN）的动机是相似的，这里的问题是，如果不使用一个隐藏层，那么如果我们使用多个隐藏层怎么办？ 因此，在这种情况下，我们的模型将类似于以下内容：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uGSaqWsI-1681654248131)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/0d594d3c-f5ca-4433-af2c-1299e12ae028.png)]

在这里，我们有相同的输入层。 但是，在这种情况下，我们将有许多隐藏层，而输出层将保持不变。 这里的关键是网络的隐藏部分，即隐藏的层。 我们有很多隐藏层，而不是只有一层，这被称为 DNN 。

深度学习

深度学习是一组基于神经网络的机器学习模型，以及使用数据训练此类模型的相关技术。 有很多深度学习模型。 它们是一类具有以下特征的机器学习算法：

• 这些模型使用一组多层非线性处理单元，可以执行抽象特征提取和转换
  
• 这些模型使用某种形式的梯度下降通过反向传播进行训练
  
• 他们通常需要大量数据和大量计算能力才能使这些模型表现出色
  
• 这些模型现在被认为是许多应用的最新技术，例如计算机视觉，语音识别和游戏
  

MLP 模型的元素

在多层感知器中构建深度学习模型时，需要考虑很多因素。 您必须考虑架构，激活函数，优化算法，loss函数，权重初始化策略，正则化策略和训练策略。 我们将在以下列表中讨论有关它们的更多信息：

• 架构：构建深度学习模型时，您需要考虑的第一个元素是 MLP 的架构。 当我们说架构时，我们在谈论的是层数和每层神经元数。 输入层中神经元的数量由数据集中的特征数量决定。 输出值的数量也是如此。 因此，它们基本上由您在分类设置中的问题确定。 输出值的数量通常是分类问题中的类数，而在回归问题中，输出层中将只有一个输出。 您必须做出的选择是要使用多少个隐藏层以及每个隐藏层的神经元数量。 设置这些数字并不容易。 实际上，我们要做的是首先使用几层。 如果有几层不起作用，也许我们增加更多层，每层的神经元数量就是输入值数量和输出数量[n_inputs, n_outputs]之间的数字。

这只是一个经验法则。 但是，有更多正式的方法可以选择隐藏层的数量和神经元的数量，研究人员一直在努力寻找更好的方法来选择这些值。

• 激活函数：激活函数是在隐藏层的每个神经元中使用的函数。 有很多选择。 Sigmoid 是开发这些模型时使用的第一个函数，但随后研究人员发现使用此函数存在许多问题，因此他们提出了其他激活函数，例如整流线性单元（ReLU），双曲正切，LReLU 以及我们将在进行中的示例中使用的其他一些选择。
  
• 优化算法：这是用于学习网络权重的算法。 您选择的每种算法都有不同的超参数，建模者需要您选择它们。 训练这些网络的最基本算法是梯度下降。 但是，梯度下降的速度可能很慢并且存在一些问题，因此研究人员提出了其他算法，例如动量优化器， AdaGrad ， RMSProp 和 Adam 算法。 在 TensorFlow 中，我们可以选择很多算法，包括 Adam 算法，而这实际上是我们将在示例中使用的算法。
  
• 损失函数：此函数将产生将由优化器最小化的数量。 损失函数的选择取决于问题。 如果我们正在做回归问题，则可以选择均方误差或均对均方误差。 对于分类问题，有更多选择，例如交叉熵，平方损失和铰链损失。 这类似于反复试验。 有时候，一个损失函数会解决您的问题，有时却不会。 因此，这就是为什么您必须考虑许多不同的损失函数的原因。 但是，请记住，损失函数将产生数量，该数量将用于优化算法，以调整将成为网络一部分的不同感知器的不同权重。 因此，这是将产生数量的函数，优化器的目标是使该数量尽可能小。
  
• 权重初始化策略：必须使用一些值来初始化网络中每个感知器的权重，并且优化算法将逐步更改这些值以最大程度地减少损失。 您可以通过多种方式初始化这些值。 您可以用全零初始化。 多年来，研究人员习惯于使用随机正态分布进行初始化，但近年来，研究人员提出了更好的选择，包括 Xavier 初始化和 He 初始化。
  
• 正则化策略：这是一项可选功能，但强烈建议您使用该功能，因为深度学习模型由于计算出的参数数量过多，往往会过拟合数据。 您可以使用许多选择，包括 L1 正则化，L2 正则化和丢弃正则化策略。 在本书中，我们不会在示例中使用正则化，但请记住，如果您要构建真正有效的深度学习模型，则很有可能需要正则化策略。
  
• 训练策略：训练策略是指将数据呈现给训练算法的方式。 这不是模型本身的一部分，但是会影响模型的结果和表现。 在谈论训练深度学习模型时，您会听到“周期”一词。 一个周期是所有训练实例通过网络的第一步。 在这些深度学习模型中，您将不得不多次将数据呈现给网络，以便网络可以为模型学习最佳参数。 这里还有另一个概念：批量大小。 这是同时显示给训练算法的元素数量。 因此，在深度学习模型的情况下，我们不向模型提供整个训练数据集。 我们要做的是呈现数据集的批量，并且在每批量中，我们仅发送几个示例，也许是 100 或 50，这就是我们训练深度学习模型的方式。 现在，您可以使用周期和批量大小来计算模型中的迭代次数，这就是训练步骤数，这是优化算法对模型权重进行调整的次数。 因此，例如，如果您有 1,000 个训练示例，并且将使用的批量大小为 100，则将需要 10 次迭代才能完成一个周期。 您可以使用以下公式获得迭代总数：
  

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1FEWrYfS-1681654248131)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c5dca712-14af-4483-8080-112349aedbb5.png)]

因此，作为建模者，您必须做出许多决定。 这些是非常复杂的模型，并且训练起来很棘手。 因此，在开始使用这些模型之前，请考虑以下指导：

• 由于我们在这些模型中拥有众多选择，因此构建它们可能非常棘手。 因此，在进行预测时，它们不应该是您的首选。 始终从更简单，更易理解的模型开始，然后，如果这些模型不起作用，则转向更复杂的模型。
• 我们已经为所有选择提供了最佳实践，但是如果您想构建有效的深度学习模型，则需要更多有关这些元素的知识。
• 为了使这些模型表现出色，您需要大量数据。 因此，您不能将这些模型用于非常小的数据集。
• 了解有关这些模型的理论的更多信息，以了解如何更好地使用它们。 因此，如果您真的想使用这些模型来解决实际问题，则必须进一步了解这些模型背后的理论。

TensorFlow 简介

TensorFlow 是一个开源软件库，用于使用数据流图进行数值计算。 计算图的概念在 TensorFlow 中非常重要，并且是专门为创建深度学习模型而设计的。 该库允许开发人员将计算部署到台式机，服务器甚至移动设备中的一个或多个 CPU 或 GPU。 该库最初由 Google 的研究人员和工程师开发。 它于 2015 年开源，从那时起，它已成为机器学习领域的主要库之一。

TensorFlow 提供了多个 API，它们可以分为以下两种类型：

• 低级：也称为 TensorFlow Core，这是最低级的 API。 该 API 为我们提供了完整的编程控制，面向在构建深度学习模型时需要高度灵活性的研究人员和用户。
• 高级：高级 API（例如tf.contrib.learn，keras和 TF-Slim）通常更易于使用。 他们负责重复性任务和低级细节，作为高级用户，您无需担心。 它们是为快速实现常用模型而设计的。

TensorFlow 安装

现在，为安装做准备，我们将在 Anaconda 中创建一个新的虚拟环境。 我们可以按照以下说明进行操作：

1. 我们打开 Anaconda 提示符。
2. 我们键入以下命令行来创建新的虚拟环境，并使用anaconda传递环境名称，这将安装 Anaconda 随附的所有包：

conda create-n apa anaconda

apa代表高级预测分析。 安装可能需要一些时间，具体取决于您的互联网速度。

3. 安装完成后，键入activate apa激活新的虚拟环境。 这是 Anaconda 提示的屏幕截图，显示了 Anaconda 包的安装：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yr4C97fB-1681654248131)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/165875cf-3aff-4480-9425-a511a15e8cb8.png)]

现在，新的虚拟环境已激活，我们准备在此新的虚拟环境中安装 TensorFlow。

但是在安装 TensorFlow 之前，您必须知道基本上有以下两种 TensorFlow 安装：

• 仅具有 CPU 支持的 TensorFlow
• 具有 GPU 支持的 TensorFlow

第二个选项通常更快，因为它使用您的计算机或设备中的 GPU，但是此安装需要 Nvidia 支持。 您还需要其他软件才能运行此安装，安装起来有点复杂。

在这里，为简便起见，我们将安装和使用 CPU 版本，因为除了速度之外，编写程序以及在 CPU 或 GPU 版本中运行程序没有区别。 我们使用以下代码行在我们的系统中安装 TensorFlow：

pip install --ignore-installed --upgrade tensorflow

运行代码时，将启动 TensorFlow 的安装，安装完成后，您将在屏幕上看到以下输出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kALlPj9d-1681654248131)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/095eddc0-a439-417a-b2c0-da57bc00ed32.png)]

现在，我们将通过执行以下步骤来启动 Python Shell 来测试安装：

1. 我们输入python启动 Python shell。
   
2. 我们使用import tensorflow as tf将 TensorFlow 导入我们的 Python shell。
   
3. 我们运行hello = tf.constant("Hello"); 这将创建一个名为hello的常量。
   
4. 我们使用sess = tf.Session()创建会话。
   

如果您看到与以下屏幕截图类似的警告消息，则可以忽略它们，因为它们只是告诉您可以使用其他选项进行安装，因此 TensorFlow 可能运行得更快。

5. 让我们通过使用print(sess.run(hello))在会话中运行常量来打印hello的结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DmmrdkZJ-1681654248132)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/06b5fd15-2128-45b1-a376-648c9ec656a7.png)]

如果您得到Hello的结果（类似于此屏幕截图），则表明我们的安装正确。 因此，现在我们准备使用 TensorFlow 来构建一些模型。

TensorFlow 的核心概念

在实际使用tensorflow库之前，我们需要了解一些主要概念。 以下是我们将在本书中介绍的概念：

• 张量
• 计算图
• 会话
• 变量
• 占位符
• 常量

张量

张量是 TensorFlow 中数据的中央单元。 张量由一组原始值组成，这些原始值成形为任意数量的维数组。 它基本上是类似于 NumPy 数组的多维数组。 维数定义张量的等级。 让我们看下面的一些例子：

• 3：如果我们只有一个数字，则将张量视为等级0张量。 这可以是shape[]的标量。
• [2., 2., 1.]：如果我们有一个向量，它将被认为是等级1张量，因此我们将其称为形状3的向量，因为它具有三个元素。
• [[9., 5., 3.], [4., 5., 7]]：形状为[2, 3]的矩阵将是等级2张量。
• [[[8., 3.]], [[7., 9.,]]]：形状为[2, 1, 2]的矩阵将是等级3张量，如您在最外层看到的，我们有两个元素，在下一层，我们只有一个元素，在最后一维， 我们有两个特征。 这就是为什么我们将2，1和2用作值并且它们都是张量的原因。

计算图

计算图是布置在节点图中的一系列 TensorFlow 操作，也称为 OPS。 TensorFlow Core 使用以下两个基本步骤：

1. 定义计算图
2. 运行计算图

让我们尝试通过一个非常简单的示例来理解这个概念。 假设您有一个带有两个变量的函数，x和y，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q9kCMj4Y-1681654248132)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/5212c92e-d91d-4024-ac39-d753f31f3926.png)]

当您传递x和y的值3和 2 时，我们将使用上述公式来计算或构建此函数的实际值的计算图 ] 分别：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HzHIqyT2-1681654248132)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/4127c2a0-3c52-4a52-85a3-f1f9e63d87cf.png)]

现在，让我们构建一个计算图以实际从该计算模型中获取结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ujtHmnuv-1681654248132)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/ef618ce1-282e-41fd-9b3f-55b6317130f4.png)]

在前面的屏幕截图中，我们看到了通过计算图流到图中不同节点的值。 因此，在第一个节点中，将值3分配给x，在另一个节点中，将值2分配给y。 现在，x的值流到一个运算节点，在该运算节点上平方，该节点的结果流到另一个运算，在运算上与y的值相乘。 我们还有另一个节点，其中y的值乘以4。x和y乘法节点的结果以及y乘法节点的结果流到最终节点，即加法节点，这为我们产生最终输出26。 因此，这基本上就是 TensorFlow 的工作方式。 节点之间流动的是张量。

我们在 TensorFlow 中使用以下其他对象：

• 会话：会话是封装执行操作对象的环境的对象。 因此，会话是将操作放置在 CPU 或 GPU 等设备上的对象。
• 占位符：占位符是对稍后提供值的承诺。 这些对象通常用于在机器学习模型中提供训练和测试值。
• 变量：这些是用值初始化的对象，该值可以在图执行期间更改。 通常，它们在机器学习模型中用作可训练变量。
• 常量：常量是其值永不变的对象。

为了更好地理解这些对象概念，让我们看一个例子。 首先，我们将通过执行以下代码片段导入所需的库：

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

然后，通过执行以下代码片段，定义一些 TensorFlow 对象，占位符和常量：

#Placeholders
x = tf.placeholder(tf.float32)
y = tf.placeholder(tf.float32)
c = tf.constant(5)

在这里，我们定义了一个占位符x和另一个占位符y。 您必须明确给出将在 TensorFlow 中使用的对象类型，在我们的示例中为float32。 然后，我们定义一个常量c，其值为5。

创建这些对象之后，如果尝试打印它们，将看不到该对象的值，但是它将显示该对象的类型，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gMdNdljU-1681654248132)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/0760ad7d-7c77-46e1-b4e7-fd8c6607998f.png)]

现在，让我们用占位符实现以下函数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ThbfRDJB-1681654248133)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/39bb9a13-593d-4fd6-a16f-23b7d66715fb.png)]

通过执行以下代码行，我们将使用刚刚创建的占位符为图定义不同的节点：

square_node = x*x
mult_node = square_node*y
quadruple_node = 4*y
adder_node = mult_node + quadruple_node

同样，如果尝试打印这些对象的值，则将得到对象类型，而不是如下面的屏幕快照所示的值：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XKkWUW9m-1681654248133)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/a9eb5f4e-f40b-4fa1-8adf-bc449ca8d24d.png)]

因此，要执行这些对象的计算，必须创建一个会话对象，然后在会话中运行所有对象：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K0nHdbxw-1681654248133)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/8ebba675-9c71-4e31-b536-c84c7098babd.png)]

如果您要进行一些计算，则无需定义计算图，因为 TensorFlow 会在后台进行。 因此，假设您要计算f并打印该值，它仍将提供对象类型。 但是要在执行计算时实际看到f的值，我们将在会话对象中再次运行该函数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tgZGtwww-1681654248133)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e94fb92f-b91a-44bd-9843-10f8d1c6acb7.png)]

您可以通过两种方式在 TensorFlow 中运行对象。 还有其他方法，但是这些是运行对象的基本且最常见的方法。 您可以在会话中使用run()方法，也可以在张量中使用eval()方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y6iGwyC3-1681654248133)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/3bd8b8d8-0c08-4461-a214-2376e38ce378.png)]

如我们所见，我们使用with语句创建了一个会话，并在该语句内运行了这两个方法。

现在，我们将建立一个基本的线性模型。 我们将让 TensorFlow 猜测以下屏幕快照中显示的b和w参数的最佳值：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mDMGZqre-1681654248134)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/270794dc-53bd-4673-8207-ca8fe98c51ec.png)]

在前面的公式中，w的值为5，b的值为1。 我们将使用这些值进行训练并将这些值绘制在散点图上：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kf4cybB4-1681654248134)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/8ed0ddf5-88be-4207-9482-3e5d43cf1f3b.png)]

如您所见，我们在两个值之间具有线性关系。

现在，我们将使用值0初始化变量对象w和b，它们将成为我们的可训练参数。 占位符通常是我们用来传递数据的对象，因此我们将创建两个占位符x和y，现在线性模型将成为计算图中的节点之一。 然后，我们将定义一个loss函数，优化器将使用该函数实际更改变量的值。 每次我们运行训练操作时，优化器都会调整w和b的值，以最大程度地减少损失。 然后我们将初始化变量并创建一个会话以运行init初始化器节点，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tq1V99CL-1681654248134)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/ba6befb8-56cb-4e28-b2eb-f0a824fec4ac.png)]

现在，我们可以开始训练我们的机器学习模型。 我们将进行 20 次训练操作，这将对w和b的值进行校正以最大程度地减少损失：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-feifRcvg-1681654248134)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/fb974a24-7293-41d3-a968-b0adf65204e8.png)]

如我们所见，在第一次迭代之后，优化器校正了w和b的值，这也在每次迭代中执行。

我们也可以使用一些线性代数进行此操作，但请记住，机器学习的目标是实际从数据中学习参数，在这种情况下，我们已经使用 TensorFlow 运行了我们的第一个机器学习模型。

总结

在本章中，我们讨论了人工神经网络，深度学习以及深度学习模型的特征。 然后，我们安装了 TensorFlow，并了解了我们在 TensorFlow 中使用的核心概念。

在下一章中，我们将使用 TensorFlow 和深度学习执行预测分析。

五、将 TensorFlow 和深度神经网络用于预测分析

TensorFlow 是 Google Brain Team 开发的开源库。 它用于大型机器学习应用（例如神经网络）中，并用于进行数值计算。 开发人员可以使用 TensorFlow 创建数据流图。 这些图显示了数据的移动。 TensorFlow 可用于为各种应用（例如图像识别，机器语言翻译和自然语言处理）训练和运行深度神经网络。

我们已经知道预测分析是关于提供未知事件的预测。 我们将在这里将其与 TensorFlow 一起使用。

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

• 使用 TensorFlow 进行预测
• 深度神经网络（DNN）的回归
• DNN 分类

将 TensorFlow 用于预测

我们将执行深度学习的hello world示例。 此示例用于检查并确保模型按预期工作。 为此，我们将使用 MNIST 数据集。

MNIST 数据集简介

MNIST 代表国家混合标准技术研究院，它已经产生了一个手写的数字数据集。 这是机器学习中研究最多的数据集之一，用于对手写数字进行分类。 由于其庞大的规模，该数据集有助于进行预测分析，从而允许深度学习有效地发挥其魔力。 该数据集包含 60,000 个训练图像和 10,000 个测试图像，格式为28 x 28像素的单色图像。 以下屏幕截图显示了此数据集中包含的图像：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OZrKSCcz-1681654248134)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/29266a1b-4e37-493c-b841-555f004034c3.png)]

在前面的屏幕截图中，我们可以看到，对于每个手写数字，都有一个对应的真实标签； 因此，我们可以使用该数据集构建分类模型。 因此，我们可以使用图像将每个数字分类为从 0 到 9 的 10 个数字之一。

使用 MNIST 数据集构建分类模型

让我们看一下以下步骤并学习建立分类模型：

1. 我们必须导入将在此数据集中使用的库。 使用以下代码行导入tensorflow，numpy和matplotlib库：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.contrib.layers import fully_connected
%matplotlib inline

2. 我们将从tensorflow.contrib.layers导入fully_connected函数，该函数将用于构建我们的网络层。

DNN 模型的元素

在运行模型之前，我们首先必须确定用于构建多层感知器模型的元素。 以下是我们将在此模型中使用的元素：

• 架构：该模型在输入层中包含 728 个神经元。 这是因为我们有 28 个图像，每个图像都有 28 个像素。 这里，在这种情况下，每个像素都是一个特征，因此我们有 728 个像素。 尽管可以使用任意数量的隐藏层，但在输出层中将有 10 个元素，并且还将使用三个隐藏层。 在这里，我们将使用三个隐藏层。 我们将在每一层中使用的神经元数在第一层为 350，第二层为 200，最后一层为 100。
• 激活函数：我们将使用 ReLU 激活函数，如以下代码块所示：

vector = np.arange(-5,5,0.1)
def relu(x) :
return max(0.,x)
relu = np.vectorize(relu)

如果输入为负，则函数输出0；如果输入为正，则函数仅输出与输入相同的值。 因此，在数学上，ReLU 函数看起来与此相似。 以下屏幕截图显示了用于生成 ReLU 激活函数的图形表示的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vpTLWF5q-1681654248135)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e5bfc50a-2e28-44e0-8cf2-294a24807836.png)]

在0和输入之间获得最大值。 该激活函数将用于隐藏层的每个神经元。

• 优化算法：此处使用的优化算法是学习率为 0.01 的梯度下降。
  
• 损失函数：对于loss函数，我们将使用cross_entropy函数，但是与本书中使用的其他损失函数一样，该函数将测量实际值与测量值之间的距离。 模型做出的预测。
  
• 权重初始化策略：为此，我们将使用 Xavier 初始化器，该方法实际上是 TensorFlow 的fully_connected函数默认提供的方法。
  
• 正则化策略：我们将不使用任何正则化策略。
  
• 训练策略：我们将使用 20 个周期。 数据集将被呈现给网络 20 次，并且在每次迭代中，我们将使用 80 的批量大小。因此，我们将数据一次呈现给网络 80 个点，并将整个数据集呈现给网络 20 次。
  

建立 DNN

现在，我们将导入将要使用的数据集。 使用此数据集的原因是它易于获取。 我们将实际使用此数据集并围绕它构建 DNN 模型。 在下一节中，我们将看到构建 DNN 模型的步骤。

读取数据

在这里，我们读取单元格中的数据。 以下屏幕截图显示了用于读取数据的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UCDG4Qa9-1681654248135)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/d3aaf54f-010c-4f34-a41a-d7f11fef7522.png)]

定义架构

我们将使用三个隐藏层，第一层为 256 个神经元，第二层为 128 个，第三层为 64 个。 以下代码段显示了分类示例的架构：

n_inputs = 28*28
n_hidden1 = 350
n_hidden2 = 200
n_hidden3 = 100
n_outputs = 10

输入和标签的占位符

不同层的值是对象，也称为输入和标签的占位符。 这些占位符用于将数据馈入网络。 以下代码行用于显示输入和标签的占位符：

X = tf.placeholder(tf.float32, shape=[None, n_inputs])
y = tf.placeholder(tf.int64)

因此，对于特征（即输入层），我们有一个占位符X；对于目标值，我们有一个占位符y。 因此，此对象将包含数字的实际真标签。

建立神经网络

为了构建 DNN，我们将fully_connected函数用于第一个隐藏层。 此隐藏层的输入是x，它是来自占位符的数据。 n_hidden1是我们在此隐藏层中拥有的神经元数量，您会记得是 350 个神经元。 现在，此隐藏层 1 成为隐藏层 2 的输入，n_hidden2是该层中神经元的数量。 同样，隐藏层 2 成为第三个隐藏层的输入，我们将在这一层中使用此数量的神经元。 最后，我们将称为logits的输出层是用作输入的全连接层，即隐藏层 3。以下屏幕截图显示了用于构建神经网络的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y1IB49IB-1681654248135)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/02a2f19c-c256-420c-9373-11069daa5387.png)]

我们输入 10 作为输出，因为分类问题中有 10 个类别，并且我们知道在输出层中不使用任何激活函数。

损失函数

对于我们的loss函数，我们使用交叉熵函数。 TensorFlow 为我们提供了许多这样的函数。 例如，在这种情况下，我们使用sparse_softmax_cross_entropy _with_logits函数，因为在这里我们从网络上获得了logits。 因此，在此函数中，我们传递了实际的标签。 这些是真实的标签，它们是logits，即我们网络的结果或输出。 以下屏幕截图显示了代码行，这些代码行用于显示reduce_mean函数与该交叉熵的使用，以获取损失：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aLXNytkL-1681654248135)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/73884877-d7ad-4b6c-90d8-2b054d336ead.png)]

现在，使用这种交叉熵，我们可以将损失计算为将在此处获得的向量的平均值。 因此，这是loss函数和交叉熵的平均值。

定义优化器和训练操作

优化器的目标是最大程度地减少损失，它可以通过调整网络所有层中的不同权重来实现。 这里使用的优化器是学习率为0.01的梯度下降。 以下屏幕快照显示了用于定义优化器的代码行，还显示了训练操作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ASLk1DEM-1681654248135)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/2861b9b5-3425-4cbc-917c-34c6bebfb8fc.png)]

每次我们运行训练操作training_op时，优化器都会稍微改变这些权重的值。 这样做可以最大程度地减少损失，并且预测值和实际值应尽可能接近。

训练策略和分类准确率评估

在这里，我们设置训练策略。 我们将使用 20 个周期，批量大小为 80。在所有这些单元格中，我们已经建立了将在该程序中使用的计算图。 以下屏幕截图显示了用于显示训练策略的代码行以及用于评估分类准确率的两个节点：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E8kqAlnv-1681654248136)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c059d22e-2a90-4e34-94ba-d7f806e01d5a.png)]

运行计算图

为了实际运行计算图，首先我们将初始化程序中的所有变量。 以下屏幕截图显示了用于运行计算图的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-08Acc7b5-1681654248136)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/dfff9daa-7bfb-4207-bb88-7419a4c8654a.png)]

在第 3 行中，我们初始化程序中的所有变量。 现在，在这里，我们没有任何明确的变量。 但是，内部的变量是全连接。 fully_connected函数是我们包含权重的所有隐藏层的地方。 这些就是变量，这就是为什么我们必须使用global_ variables_initializer对象初始化变量并运行此节点的原因。 对于每个周期，我们运行此循环 20 次。 现在，对于批量数量超过 80 的示例数量中的每次迭代，我们将获得特征和目标的值。 因此，每次迭代将有 80 个数据点。 然后，我们运行训练操作，并将通过x； 我们将传递特征值，在这里我们将传递目标值。 请记住，x和y是我们的占位符。 然后，我们评估训练的准确率，然后评估测试数据集中的准确率，从而获得测试数据集。 我们来自mnist.test.images，因此现在这些都是特征，test.labels是目标。 然后，在这两个循环完成之后，我们将打印两个精度。

然后，我们为测试数据集中的前 15 张图像生成一些单独的预测。 运行此步骤后，我们获得了第一个周期，其训练准确率为 86%，测试准确率为 88-89%。 以下屏幕截图显示了训练的结果以及不同周期的测试结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N6xuL6Oa-1681654248136)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/16acb53f-7d10-4c38-9d16-273f6bd7b386.png)]

这些程序需要一点时间才能运行，但是经过 20 个星期之后，测试准确率几乎达到了 97%。 以下屏幕截图显示了实际标签和预测标签。 这些是网络所做的预测：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R7MGgftZ-1681654248136)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/affdeb3b-3f28-4b4b-a801-43210ca51816.png)]

因此，我们建立了第一个 DNN 模型，并且使用该程序能够以接近 97% 的准确率对手写数字进行分类。

深度神经网络（DNN）的回归

对于 DNN 的回归，我们首先必须导入将在此处使用的库。 我们将使用以下屏幕快照中显示的代码行导入 TensorFlow，pandas，NumPy 和 matplotlib：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3krB1OvD-1681654248136)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/d2622fc4-ef72-4d49-ac2e-025f5c814142.png)]

我们将使用tensorflow.contrib.layers模型中的fully_ connected函数。

DNN 模型的元素

在运行模型之前，我们首先必须确定用于构建多层感知器模型的元素，如下所示：

• 架构：该模型在输入层中包含 23 个元素，因此在此数据集中有 25 个特征。 尽管可以使用任意数量的隐藏层，但在输出层中只有一个元素，并且将使用三个隐藏层。 我们将在第一层使用 256 个神经元，第二层使用 128 个神经元，第三层使用 64 个神经元。 这是两个的力量。
• 激活函数：我们将选择 ReLu 激活函数。
• 优化算法：这里使用的优化算法是 Adam 优化器。 Adam 优化器是最受欢迎的优化器之一，因为它是解决许多问题的最佳选择。
• 损失函数：我们将使用均方误差，因为我们在这里进行回归问题，这是loss函数的最佳选择之一。
• 权重初始化策略：为此，我们将使用 Xavier 初始化器，它是 TensorFlow 中fully_connected函数的默认设置。
• 正则化策略：我们将不使用任何正则化策略。
• 训练策略：我们将使用 40 个周期。 我们将数据集呈现给网络 40 次，并且在每次迭代中，每次运行训练操作时，我们都会使用 50 个数据点的批量。 因此，我们将使用数据集中的 50 个元素。

建立 DNN

首先，我们导入将要使用的数据集。 使用此数据集的原因在于，它易于获得。 以下是构建 DNN 模型的步骤。

读取数据

我们将读取单元格中的数据并将其过滤为我们的首选项。 以下屏幕截图显示了用于读取数据的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EEBEou4E-1681654248137)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/60d20624-6098-4ad9-8d91-a1b138c925b6.png)]

建模对象

导入数据集后，我们准备对象以进行建模。 因此，我们在这里进行了x和y的训练和测试。 以下屏幕快照显示了用于准备对象以进行建模的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eaSR0pCl-1681654248137)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e9278a94-5327-4ee6-bd04-3a925170420e.png)]

训练策略

这是具有 40 个周期且批量大小为 50 个的训练策略。它是使用以下代码行创建的：

n_epochs = 40
batch_size = 50

DNN 的输入管道

由于这是一个外部数据集，因此我们必须使用数据输入管道，并且 TensorFlow 提供了用于在深度学习模型内部获取数据的不同工具。 在这里，我们创建一个数据集对象和一个迭代器对象，其中的代码行如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6DHmU8Sh-1681654248137)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/edc095ad-d63a-4b69-87c3-3d262b2e7345.png)]

首先，我们生成数据集对象。 然后，我们将整个训练数据集传递给一些将要使用的占位符。 然后，我们对数据进行混洗，并将训练数据集分为 50 个批量。因此，准备了数据集对象，其中包含所有训练样本，这些样本均被分为大小为 50 个批量。接下来，我们创建一个迭代器对象。 然后，使用get_next方法，创建一个名为next_element的节点，该节点从训练示例中提供了 50 个批量。

定义架构

我们使用三个隐藏层，第一层为 256 个神经元，第二层为 128 个，第三层为 64 个。 以下代码段显示了此过程的架构：

n_inputs = X_train.shape[1] #23
n_hidden1 = 256
n_hidden2 = 128
n_hidden3 = 64
n_outputs = 1

输入值和标签的占位符

不同层的值是对象，也称为占位符，用于输入和标签。 这些占位符用于将数据馈入网络。 以下代码行显示了输入和标签的占位符：

X = tf.placeholder(X_train.dtype, shape=[None,n_inputs])
y = tf.placeholder(y_train.dtype)

建立 DNN

为了构建以下示例，我们首先必须定义DNN函数。 该函数将获取X_values并输出预测。 对于第一个隐藏层，我们使用fully_ connected函数。 此隐藏层的输入为X，它是来自占位符的数据，而n_hidden1是我们在此隐藏层中拥有的神经元数。 请记住，在第一个隐藏层中有 350 个神经元。 现在，第一个隐藏层成为第二个隐藏层的输入，n_hidden2是我们在第二个隐藏层中使用的神经元数量。 同样，第二个隐藏层成为第三个隐藏层的输入，我们在这一层中使用此数量的神经元。 最后，我们有了输出层，我们称它为y_pred，这是一个全连接层，其中第三个隐藏层为输入。 这是一个输出，该层没有激活函数。 以下屏幕截图显示了用于构建神经网络的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W0RhPnKY-1681654248137)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e509c688-e82a-44e0-a99b-1abce7126c60.png)]

损失函数

我们将使用mean_squared _error函数-TensorFlow 为我们提供了许多这样的函数。 我们传递观测值和预测值，并且此函数计算均方误差。 以下屏幕截图显示了用于显示mean_squared _error函数的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-36iKHrdW-1681654248137)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/cedfa97e-88ee-4564-9297-6299ce5e7652.png)]

定义优化器和训练操作

优化器的目标是最大程度地减少损失，它可以通过调整网络所有层中的不同权重来实现。 此处使用的优化器是学习率为 0.001 的 Adam 优化器。

以下屏幕快照显示了用于定义优化器的代码行，还显示了训练操作：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q7f0Jx70-1681654248138)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/d34af37c-db85-4d8d-82ec-1274c6805ea2.png)]

以下屏幕快照显示了我们创建的一些 NumPy 数组，这些数组将用于评估目的：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XUoIOVbV-1681654248138)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/88fcf3a8-6cf2-4475-b25e-d7ee0db78a4b.png)]

运行计算图

为了实际运行计算图，首先我们将初始化程序中的所有变量。 以下屏幕截图显示了用于运行计算图的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s5d9Z0zg-1681654248138)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/ea17818a-74ea-4811-ad41-4040102b4673.png)]

变量是fully_connected函数中隐含的权重。 然后，对于每个周期，我们初始化迭代器对象并传递训练数据集。 在这里，我们有batch_data，我们运行此next_ element节点，并得到 50 个批量。我们可以获取特征值和标签，我们可以获取标签，然后可以运行训练操作。 当对象数据用完时，我们会收到错误消息。 在这种情况下，当我们遇到这些错误之一时，这意味着我们已经使用了所有训练数据集。 然后，我们从while循环中跳出，进入下一个周期。 稍后，我们产生一些单独的预测，因此您可以查看该神经网络所做的具体预测。

以下屏幕截图显示了在我们向该网络展示数据时所有 40 个周期的训练和测试 MSE 的行为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gNooBUDO-1681654248138)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e9121538-21c3-43f6-8fe0-59ecaa8da16e.png)]

在最后一次测试的 MSE（周期 40）中，我们获得了训练和测试的 MSE 的最终值。

我们从网络获得了实际的预测，并且值相对接近。 在这里，我们可以看到预测价格。 对于廉价钻石，该网络产生的值相对接近。 对于非常昂贵的钻石，网络产生了很高的值。 而且，预测值与观察值非常接近。 以下屏幕截图显示了我们从网络获得的实际值和预测值：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DD3QzoL6-1681654248138)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c37daf44-699d-4ec7-a142-2c8cfb057b90.png)]

以下屏幕快照显示了带有测试 MSE 的训练 MSE 的图形以及用于生成它的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jtfSmnjR-1681654248139)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/d41fa0ad-74c9-4232-b9e7-e8788788c194.png)]

DNN 分类

为了了解 DNN 的分类，我们首先必须了解指数线性单元函数的概念和模型的元素。

指数线性单元激活函数

指数线性单元（ELU）函数是 ReLU 函数的相对较新的修改。 它看起来与 ReLU 函数非常相似，但是具有非常不同的数学特性。 以下屏幕截图显示了 ELU 函数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LHYkvz2R-1681654248139)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/1e4604f6-28a4-4da0-9faa-de706a4da045.png)]

上面的屏幕截图显示，在0处，我们没有拐角。 对于 ReLU 函数，我们有一个角落。 在此函数中，我们将 ELU 函数缓慢地移至负alpha参数，而不是将单个值移至0。

DNN 分类

对于 DNN 分类，我们首先必须导入将要使用的库。 使用以下屏幕快照中的代码行导入tensorflow，pandas，numpy和matplotlib库：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fBOk5eSI-1681654248139)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e70a38d6-3326-48a1-a4e2-2a8156ff1188.png)]

我们还将从sklearn.model_selection导入train_test_split函数，从sklearn.preprocessiong导入RobustScaler函数，并从sklearn.metrics导入precision_score，recall_score和accuracy_score。 我们还从tensorflow.contrib.layers导入fully_connected函数以构建我们的网络层。

DNN 模型的元素

在运行模型之前，我们首先必须确定在构建多层感知器模型的

中将使用的元素，如下所示：

• 架构：该模型在输入层中包含 25 个元素，因为我们在数据集中具有
  25 个特征。 在输出层中我们有两个元素，尽管我们可以使用任意数量的隐藏
  层，但
  也将使用三个隐藏层。 我们将在每层中使用相同数量的神经元，即 200。在这里，我们使用
  的 2 的幂进行选择。
  
• 激活函数：我们将选择 ELU 激活函数，该函数在上一章中已说明。
  
• 优化算法：这里使用的优化算法是 Adam 优化器，学习率为 0.001。
  
• 损失函数：对于loss函数，我们将使用交叉熵函数。
  
• 权重初始化策略：为此，我们将使用 Xavier 初始化器，这是默认方法，该方法与 TensorFlow 中的fully_connected函数一起提供。
  
• 正则化策略：我们将不使用任何正则化策略。
  
• 训练策略：我们将使用 40 个周期。 因此，我们将 40 次数据集
  呈现给网络，并且在每次迭代中，我们将使用 100 的批量大小。
  

建立 DNN

现在，我们导入将要使用的数据集。 使用此数据集的原因是

易于获得。 以下是构建 DNN 模型的步骤。

读取数据

我们将读取单元格中的数据。 以下屏幕截图显示了

用来读取数据的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-48SnbzKv-1681654248139)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/dfee505c-4e6a-46e0-aafc-a1a73825fa69.png)]

生成用于建模的对象

现在，我们生成用于建模的对象。 我们将使用 10% 的测试

和 90% 的训练。 以下屏幕截图显示了

用于生成建模对象的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mUo3xODB-1681654248139)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/57d58fe3-2781-4cb0-b875-cbf1ef50ebcb.png)]

训练策略

这是我们前面提到的训练策略，共 40 个周期，批量大小为

100。以下代码块显示了我们在此策略中设置的参数：

n_epochs = 40
batch_size = 100

DNN 的输入管道

现在，我们执行与回归示例相同的操作。 我们创建一个

dataset对象和一个迭代器对象。 最后，我们有next_element。 这将是我们计算图中的一个节点，每次将为我们提供 100 个数据点。 因此，我们得到了

批量。 以下屏幕快照显示了用于为 DNN 生成输入

管道的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m4n2lwL3-1681654248140)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/b2c44778-8a38-4d4a-ae49-bac788b96ee4.png)]

定义架构

我们将对所有三个使用三个隐藏层和 200 个神经元。 以下代码段

显示了本示例中将使用的架构：

n_inputs = X_train.shape[1] #25
n_hidden1 = 200
n_hidden2 = 200
n_hidden3 = 200
n_outputs = 2

输入和标签的占位符

不同层的值是输入和

标签的对象，也称为占位符。 这些占位符用于将数据馈入网络。 下面的

代码行用于显示输入和标签的占位符：

X = tf.placeholder(X_train.dtype, shape=[None,n_inputs])
y = tf.placeholder(y_train.dtype)

建立神经网络

为了构建深度神经网络，我们将使用DNN函数。 我们分为三层，我们将使用 ELU 函数作为激活函数。 您可以从 TensorFlow，tf.nn.elu中获得此函数，从中您可以获得许多函数，这些函数将帮助您构建深度学习模型。 以下屏幕截图显示了用于产生此函数并以logits形式获取输出的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O5Q5p3mV-1681654248140)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/e5e00979-4492-4f24-9bbd-666d6c417cc6.png)]

最后一层称为logits层。 我们不会在的这一层中使用任何激活函数。

损失函数

对于loss函数，我们再次从 DNN 获取logits，然后将此logits传递给 TensorFlow 的softmax_cross_entropy_with_logits函数。 我们传递真实的标签和logits，然后通过将reduce_mean函数与cross_entropy一起使用来获得损失。 以下屏幕截图显示了用于显示cross_entropy函数和cross_entropy的使用的代码行，以获取损失：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HgP48U6x-1681654248140)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/2c3d959e-568f-4e50-bf45-e28bcaf89b8c.png)]

评估节点

现在，为了进行评估，我们将计算默认变量和非默认变量的概率； 您可以通过将softmax函数应用于logits来获得概率。 以下屏幕截图显示了softmax函数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wDHoNpbc-1681654248140)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/c08b33df-ddba-4203-8a20-c7c8d56f40cc.png)]

softmax函数用于提供不同类别的概率。

优化器和训练操作

优化器的目标是使损失最小化，它可以通过调整网络所有层中的不同权重来实现。

以下屏幕快照显示了用于定义优化器的代码行，并显示了训练操作：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zE0WGYwx-1681654248140)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/31bcbcf6-c2aa-4cd5-a759-3cf5b0a68f49.png)]

在这种情况下，优化器还是学习率为0.001的 Adam 优化器。 训练操作是优化器将损失最小化的操作。

运行计算图

为了实际运行计算图，首先我们初始化

程序中的所有变量。 变量是fully_connected函数中隐含的权重。 我们运行四个周期，并为每个周期初始化迭代器对象。 我们通过训练x和训练y，然后运行此循环。 只要next_elementelement中有数据，此循环就会运行。 因此，我们得到接下来的 100 个元素，然后在下一次迭代中得到接下来的 100 个元素，依此类推。 在每次迭代中，我们都要运行训练操作。 现在，此训练操作要做的是要求优化器稍微调整参数和权重，以便做出更好的预测。

以下屏幕截图显示了用于运行计算图的代码行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K3WOHg2e-1681654248141)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/3d0faf9a-3035-4af5-9cd1-a133bc2502cc.png)]

最后，我们可以获得概率，并将其用于评估目的。

使用设定的阈值评估模型

生成probabilities对象，以使用不同的分类阈值实际评估模型表现。 可以针对二元分类问题修改分类阈值，并且可以将其用于计算召回得分，精度和准确率。 使用分类阈值0.16时，这些是我们在测试数据集中获得的指标：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6XAdQvNv-1681654248141)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/master-pred-anal-sklearn-tf/img/f23f3ebc-019f-4be1-a50d-dd44eaec977b.png)]

通过计算，我们得出的召回得分为82.53%，准确率为34.02%，准确率为60.7%。

总结

在本章中，我们学习了如何使用 TensorFlow 进行预测。 我们研究了 MNIST 数据集和使用该数据集的模型分类。 我们遇到了 DNN 模型的元素以及 DNN 的构建过程。 后来，我们开始研究 DNN 的回归和分类。 我们对手写数字进行了分类，并进一步了解了 TensorFlow 中的构建模型。 这使我们到本书的结尾！ 我们学习了如何使用集成算法来生成准确的预测。 我们应用了各种技术来组合和构建更好的模型。 我们学习了如何有效执行交叉验证。 我们还实现了各种技术来解决预测分析领域中的当前问题。 最好的部分是，我们使用建立的 DNN 模型来解决分类和回归问题。 本书帮助我们实现了各种机器学习技术，以构建高级的预测模型并将其应用于现实世界。