如何使用 Weka 处理机器学习数据中的缺失值
原文：https://machinelearningmastery.com/how-to-handle-missing-values-in-machine-learning-data-with-weka/
最后更新于 2019 年 12 月 13 日
数据很少是干净的，并且经常会有损坏或丢失的值。
在开发机器学习模型时，为了获得最佳表现，识别、标记和处理丢失的数据非常重要。
在这篇文章中，您将发现如何使用 Weka 处理机器学习数据中缺失的值。
看完这篇文章你会知道:
- 如何标记数据集中缺失的值。
- 如何从数据集中删除缺少值的数据。
- 如何估计缺失值？
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
我们开始吧。
如何处理 Weka
中机器学习丢失的数据图片作者: Peter Sitte ，版权所有。
预测糖尿病的发作
本例中使用的问题是皮马印第安人糖尿病发病数据集。
这是一个分类问题，其中每个实例代表一个患者的医疗细节，任务是预测该患者是否会在未来五年内出现糖尿病。
您可以在此了解有关数据集的更多信息:
您也可以在您的 Weka 安装中，在名为 diabetes.arff 的文件中的 data/ 目录下访问该数据集。
标记缺失值
皮马印第安人数据集是探索缺失数据的良好基础。
血压(pres)和体重指数(Mass)等一些属性的值为零，这是不可能的。这些是必须手动标记的损坏或丢失数据的示例。
您可以使用 NumericalCleaner 筛选器标记 Weka 中的缺失值。下面的秘籍向您展示了如何使用这个过滤器来标记身体质量指数属性上的 11 个缺失值。
1.打开 Weka 浏览器。
2.加载皮马印第安人糖尿病发病数据集。
3.单击过滤器的“选择”按钮，并选择数值过滤器，它位于未监督的属性下
Weka 选择数字清洁器数据过滤器
4.单击过滤器进行配置。
5.将属性标记设置为 6，即质量属性的索引。
6.将最小阈值设置为 0.1E-8(接近零)，这是属性允许的最小值。
7.将 minDefault 设置为 NaN，该值未知，将替换阈值以下的值。
8.单击过滤器配置上的“确定”按钮。
9.单击“应用”按钮应用过滤器。
单击“属性”窗格中的“质量”，查看“选定属性”的详细信息。请注意，正式设置为 0 的 11 个属性值没有标记为缺失。
Weka 缺失数据已标记
在本例中，我们将低于阈值的值标记为缺失。
你也可以很容易地用一个特定的数值来标记它们。您还可以标记值的上下范围之间缺少的值。
接下来，让我们看看如何从数据集中移除缺少值的实例。
删除丢失的数据
既然您知道如何标记数据中缺失的值，那么您需要学习如何处理它们。
处理缺失数据的一种简单方法是移除那些具有一个或多个缺失值的实例。
您可以在 Weka 中使用 RemoveWithValues 过滤器来实现这一点。
从上述方法继续标记缺失值，您可以按如下方式删除缺失值:
1.单击过滤器的“选择”按钮，并选择移除带值，它位于未监督的实例下。
Weka 选择移除带值数据过滤器
2.单击过滤器进行配置。
3.将属性标记设置为 6，即质量属性的索引。
4.将匹配缺省值设置为“真”。
5.单击“确定”按钮使用过滤器的配置。
6.单击“应用”按钮应用过滤器。
单击“属性”部分中的“质量”，查看“选定属性”的详细信息。
请注意，标记为缺失的 11 个属性值已从数据集中删除。
删除了 Weka 缺失值
注意，您可以通过单击“撤消”按钮来撤消此操作。
输入缺少的值
不一定要删除缺少值的实例，您可以用其他值替换缺少的值。
这被称为输入缺失值。
用数字分布的平均值来估计缺失值是很常见的。您可以在 Weka 中使用 ReplaceMissingValues 过滤器轻松实现这一点。
从上面的第一个配方继续标记缺失值，您可以如下估计缺失值:
1.单击过滤器的“选择”按钮，并选择“替换缺失值”，它位于“未监督的”属性下。
Weka 替换缺失值数据过滤器
2.单击“应用”按钮将过滤器应用到您的数据集。
单击“属性”部分中的“质量”，查看“选定属性”的详细信息。
请注意，标记为缺失的 11 个属性值已被设置为分布的平均值。
Weka 估计值
摘要
在这篇文章中，您发现了如何使用 Weka 处理机器学习数据集中缺失的数据。
具体来说，您了解到:
- 如何在数据集中将损坏的值标记为缺失。
- 如何从数据集中移除缺少值的实例。
- 如何估计数据集中缺失值的平均值。
你对缺失的数据或本教程有什么疑问吗？在下面的评论中提问，我会尽力回答。
如何在 Weka 中运行你的第一个分类器
原文：https://machinelearningmastery.com/how-to-run-your-first-classifier-in-weka/
最后更新于 2020 年 12 月 10 日
Weka 让学习应用机器学习变得轻松、高效、有趣。它是一个图形用户界面工具，允许您加载数据集、运行算法以及设计和运行实验，其结果在统计上足够健壮，可以发布。
我向机器学习的初学者推荐 Weka，因为它让他们专注于学习应用机器学习的过程，而不是被数学和编程所拖累——这些都可以在后面实现。
在这篇文章中，我想向您展示加载数据集、运行高级分类算法和查看结果是多么容易。
如果你坚持下去，你将在不到 5 分钟的时间内获得机器学习结果，并有知识和信心继续尝试更多的数据集和算法。
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
1.下载 Weka 并安装
访问 Weka 下载页面找到适合你电脑(Windows、Mac 或 Linux)的 Weka 版本。
Weka 需要 Java。您可能已经安装了 Java ，如果没有，下载页面上列出的 Weka 版本(适用于 Windows)包含 Java，并将为您安装。我自己也在苹果电脑上，就像苹果电脑上的其他东西一样，Weka 开箱即用。
如果你对机器学习感兴趣，那么我知道你可以想出如何将软件下载并安装到自己的计算机中。如果您需要安装 Weka 的帮助，请参阅以下提供逐步说明的帖子:
2.启动 Weka
启动 Weka。这可能需要在程序启动器中找到它，或者双击 weka.jar 文件。这将启动 Weka 图形用户界面选择器。
Weka 图形用户界面选择器允许您选择资源管理器、实验器、知识管理器和简单命令行界面(命令行界面)之一。
Weka 图形用户界面选择器
点击 探索者 按钮，启动 Weka 探索者。
该图形用户界面允许您加载数据集和运行分类算法。它还提供了其他功能，如数据过滤、聚类、关联规则提取和可视化，但我们现在不会使用这些功能。
3.打开数据/iris.arff 数据集
点击 ***打开文件……***按钮打开数据集，双击 数据 目录。
Weka 提供了许多小的通用机器学习数据集，你可以用来练习。
选择“”文件加载虹膜数据集。
**
加载虹膜数据集的 Weka 浏览器界面
鸢尾花数据集是统计学中著名的数据集，被机器学习领域的研究者大量借用。它包含 150 个实例(行)和 4 个属性(列)以及一个鸢尾花物种的类属性(刚毛藻、云芝和弗吉尼亚之一)。你可以在维基百科上阅读更多关于鸢尾花数据集的信息。
4.选择并运行算法
现在您已经加载了一个数据集，是时候选择一个机器学习算法来建模问题并进行预测了。
点击“”选项卡。这是针对 Weka 中加载的数据集运行算法的区域。
您会注意到，默认情况下选择了“【ZeroR】**”算法。
点击 开始 按钮运行该算法。
鸢尾花数据集上零陷算法的 Weka 结果
ZeroR 算法选择数据集中的多数类(所有三种虹膜在数据中都同样存在，所以它选择第一种:setosa)，并使用它来进行所有预测。这是数据集的基线，也是可以用来比较所有算法的度量。结果是 33%，正如预期的那样(3 个类，每个类代表相等，为每个预测结果分配三个中的一个，分类准确率为 33%)。
您还会注意到，默认情况下，测试选项选择 10 倍交叉验证。这意味着数据集被分成 10 部分:前 9 部分用于训练算法，第十部分用于评估计法。重复这一过程，允许分割数据集的 10 个部分中的每个部分都有机会成为保留的测试集。你可以在这里阅读更多关于交叉验证的内容。
ZeroR 算法很重要，但很无聊。
单击“分类器”部分的“选择”按钮，然后单击“树”并单击“J48”算法。
这是 C4.8 算法在 Java 中的一个实现(“J”代表 Java，48 代表 C4.8，因此得名 J48)，是著名的 C4.5 算法的一个小扩展。您可以在这里阅读更多关于 C4.5 算法的内容。
点击 开始 按钮运行算法。
Weka J48 算法在鸢尾花数据集上的结果
5.查看结果
运行 J48 算法后，您可以在“分类器输出”部分记录结果。
该算法以 10 倍交叉验证运行:这意味着它有机会对数据集的每个实例进行预测(使用不同的训练折叠)，并且呈现的结果是这些预测的总结。
只是在 Weka 的鸢尾花数据集上的 J48 算法的结果
首先注意分类准确率。您可以看到，该模型获得了 144/150 正确率或 96%的结果，这似乎比 33%的基线好得多。
其次，看混淆矩阵。您可以看到一个实际类别与预测类别的比较表，您可以看到有 1 个错误将鸢尾分类为鸢尾色，2 个案例将鸢尾色分类为鸢尾色，3 个案例将鸢尾色分类为鸢尾色(总共 6 个错误)。此表有助于解释算法所达到的准确率。
摘要
在这篇文章中，您加载了第一个数据集，并在 Weka 中运行了第一个机器学习算法(C4.8 算法的实现)。ZeroR 算法并不算数:它只是一个有用的基线。
你现在知道如何加载 Weka 提供的数据集，以及如何运行算法:继续尝试不同的算法，看看你会得到什么。
如果你能在 Iris 数据集上达到 96%以上的准确率，请在评论中留下注释。****
如何在 Weka 中调整机器学习算法
原文：https://machinelearningmastery.com/how-to-tune-a-machine-learning-algorithm-in-weka/
最后更新于 2020 年 12 月 10 日
Weka 是学习机器学习的完美平台。
它提供了一个图形用户界面，用于在数据集上探索和实验机器学习算法，而您不必担心数学或编程。
在之前的一篇文章中，我们研究了如何在数据集上用 3 种算法设计和运行一个实验，以及如何分析和报告结果。
曼哈顿天际线，因为我们将使用曼哈顿距离和 k 近邻算法。
蒂姆·皮尔斯摄，洛斯加托斯，版权所有。
在这篇文章中，你将发现如何使用 Weka 实验者来提高你的结果，并充分利用机器学习算法。如果你按照一步一步的指导，你将在五分钟内设计并运行你的算法调优机器学习实验。
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
1.下载 Weka 并安装
访问 Weka 下载页面找到适合你电脑的 Weka 版本(Windows、Mac 或 Linux)。
Weka 需要 Java。您可能已经安装了 Java，如果没有，下载页面上列出的 Weka 版本(适用于 Windows)包含 Java，并将为您安装。我自己也在苹果电脑上，就像苹果电脑上的其他东西一样，Weka 开箱即用。
如果你对机器学习感兴趣，那么我知道你可以想出如何将软件下载并安装到自己的计算机中。
2.启动 Weka
启动 Weka。这可能需要在程序启动器中找到它，或者双击 weka.jar 文件。这将启动 Weka 图形用户界面选择器。
Weka 图形用户界面选择器
Weka 图形用户界面选择器允许您选择资源管理器、实验器、知识管理器和简单命令行界面(命令行界面)之一。
点击“实验者”按钮，启动 Weka 实验者。
Weka Experimenter 允许您设计自己的在数据集上运行算法的实验，运行实验并分析结果。这是一个强大的工具。
3.设计实验
点击新建按钮，创建新的实验配置。
测试选项
实验者用合理的默认值为你配置测试选项。实验配置为使用 10 倍的交叉验证。这是一个“分类”类型的问题，每个算法+数据集组合运行 10 次(迭代控制)。
电离层数据集
让我们从选择数据集开始。
- 在数据集中，选择点击添加新… 按钮。
- 打开数据目录，选择电离层数据集。
电离层数据集是一个经典的机器学习数据集。问题是在给定雷达信号的情况下，预测电离层中自由电子结构的存在与否。它由 16 对实值雷达信号(34 个属性)和一个具有两个值的单一类别属性组成:好的和坏的雷达回波。
您可以在电离层数据集的 UCI 机器学习知识库页面上了解更多关于此问题的信息。
调整 k 近邻
在这个实验中，我们对调整数据集上的 k 最近邻算法 (kNN)感兴趣。在 Weka 中，这种算法被称为 IBk(基于实例的学习器)。
IBk 算法并不构建模型，而是及时为测试实例生成预测。IBk 算法使用距离度量在每个测试实例的训练数据中定位 k “接近”实例，并使用这些选择的实例进行预测。
在这个实验中，我们感兴趣的是在电离层数据集上定位 IBk 算法中使用的距离度量。我们将在实验中添加该算法的 3 个版本:
欧几里得距离
- 在算法部分点击添加新的……。
- 点击选择按钮。
- 点击懒选择下的 IBk 。
- 点击 IBk 配置上的确定按钮。
这将添加带有默认距离度量欧几里德距离的 IBk 算法。
曼哈顿距离
- 在算法部分点击添加新的……。
- 点击选择按钮。
- 点击懒选择下的 IBk 。
- 在 IBk 的配置中点击“近邻搜索算法”的名称。
- 点击距离功能的选择按钮，选择曼哈顿态势。
- 点击近邻搜索算法配置中的确定按钮。
- 点击 IBk 配置上的确定按钮。
为 IBk 选择距离度量
这将添加带有曼哈顿距离的 IBk 算法，也称为城市街区距离。
切比雪夫距离
- 在算法部分点击添加新的……。
- 点击选择按钮。
- 点击懒选择下的 IBk 。
- 在 IBk 的配置中点击“近邻搜索算法”的名称。
- 点击距离功能的选择按钮，选择切比雪夫距离。
- 点击近邻搜索算法配置中的确定按钮。
- 点击 IBk 配置上的确定按钮。
这将添加带有切比雪夫距离的 IBk 算法，也称为城市棋盘距离。
4.运行实验
点击屏幕顶部的“运行”标签。
该选项卡是运行当前配置实验的控制面板。
点击大的开始按钮开始实验，观看日志和状态部分，关注进展情况。
5.查看结果
点击屏幕顶部的“分析”标签。
这将打开实验结果分析面板。
算法等级
我们首先想知道的是哪种算法是最好的。我们可以通过给定算法击败其他算法的次数来对算法进行排名。
- 点击测试基地的选择按钮，选择排名。
- 现在点击执行测试按钮。
排名表显示了每种算法相对于数据集中所有其他算法的统计显著优势。一次胜利意味着比另一种算法的准确率更高的准确率，并且差异具有统计学意义。
电离层数据集在 Weka 浏览器中的算法排名
我们可以看到曼哈顿距离变化被排在顶部，欧几里德距离变化被排在底部。这是令人鼓舞的，看起来我们已经找到了一个比这个问题的默认算法更好的配置。
算法准确率
接下来我们想知道算法取得了什么表现。
- 点击测试基地的选择按钮，在列表中选择带有【曼哈顿距离】的 IBk 算法，点击选择按钮。
- 单击“显示标准”旁边的复选框。偏差”。
- 现在点击执行测试按钮。
在“测试输出”中，我们可以看到一个表格，上面有三种 IBk 算法的结果。每个算法在数据集上运行 10 次，报告的准确率是这 10 次运行的平均值和标准差。
Weka 探索者电离层数据集算法分类准确率表
我们可以看到，带有曼哈顿距离的 IBk 达到了 90.74% (+/- 4.57%)的准确率，优于默认的准确率为 87.10% (+/- 5.12%)的欧氏距离。
带有欧几里德距离的 IBk 的结果旁边的小*”告诉我们，IBk 的曼哈顿距离和欧几里德距离变化的准确率结果是从不同的人群中得出的，结果的差异在统计上是显著的。
我们还可以看到，带有切比雪夫距离的 IBk 的结果没有“*”，这表明 IBk 的曼哈顿距离和切比雪夫距离变化之间的结果差异在统计上不显著。
摘要
在这篇文章中，你发现了如何在 Weka 中用一个数据集和一个算法的三个变体来配置机器学习实验。您发现了如何使用 Weka 实验者在数据集上调整机器学习算法的参数并分析结果。
如果你已经走了这么远，为什么不呢:
- 看看你能否进一步调优 IBk，得到更好的结果(并留下评论告诉我们)
- 设计并运行一个实验来调整 IBk 的 k 参数。
在 Weka 中为更好的预测使用提升、装袋和混合集成
最后更新于 2020 年 12 月 10 日
Weka 是研究机器学习的完美平台。
它提供了一个图形用户界面，用于在数据集上探索和实验机器学习算法，而您不必担心数学或编程。
在之前的一篇文章中，我们研究了如何设计和运行在数据集上运行 3 个算法的实验，以及如何分析和报告结果。我们还研究了如何设计和运行一个实验来调整机器学习算法的配置
在这篇文章中，你将发现如何使用 Weka 实验员通过将多种算法的结果组合成一个整体来提高你的结果。如果你按照一步一步的指导，你将在五分钟内设计并运行一个集成机器学习实验。
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
1.下载 Weka 并安装
访问 Weka 下载页面找到适合你电脑的 Weka 版本(Windows、Mac 或 Linux)。
Weka 需要 Java。您可能已经安装了 Java，如果没有，下载页面上列出的 Weka 版本(适用于 Windows)包含 Java，并将为您安装。我自己也在苹果电脑上，就像苹果电脑上的其他东西一样，Weka 开箱即用。
如果你对机器学习感兴趣，那么我知道你可以想出如何将软件下载并安装到自己的计算机中。
2.启动 Weka
启动 Weka。这可能需要在程序启动器中找到它，或者双击 weka.jar 文件。这将启动 Weka 图形用户界面选择器。
Weka 图形用户界面选择器
Weka 图形用户界面选择器允许您选择资源管理器、实验器、知识管理器和简单命令行界面(命令行界面)之一。
点击实验者按钮，启动 Weka 实验者。
Weka Experimenter 允许您设计自己的在数据集上运行算法的实验，运行实验并分析结果。这是一个强大的工具。
3.设计实验
点击新建按钮，创建新的实验配置。
测试选项
实验者用合理的默认值为你配置测试选项。实验配置为使用 10 倍的交叉验证。这是一个“分类”类型的问题，每个算法+数据集组合运行 10 次(迭代控制)。
电离层数据集
让我们从选择数据集开始。
- 在数据集中，选择点击添加新… 按钮。
- 打开数据目录，选择电离层数据集。
电离层数据集是一个经典的机器学习数据集。问题是在给定雷达信号的情况下，预测电离层中自由电子结构的存在与否。它由 16 对实值雷达信号(34 个属性)和一个具有两个值的单一类别属性组成:好的和坏的雷达回波。
您可以在电离层数据集的 UCI 机器学习知识库页面上了解更多关于此问题的信息。
集成方法
J48 ( C4.8 )是一种强大的决策树方法，在电离层数据集上表现良好。在本实验中，我们将研究是否可以使用集成方法来改进 J48 算法的结果。我们将尝试三种流行的集成方法:提升、装袋和混合。
让我们从将 J48 算法添加到实验开始，这样我们就可以将其结果与该算法的集成版本进行比较。
将 J48 算法添加到 Weka 实验者中。
- 在算法部分点击添加新的……。
- 点击选择按钮。
- 点击树选择下的 J48 。
- 点击 AdaBoostM1 配置上的确定按钮。
提升
Boosting 是一种集成方法，从基于训练数据准备的基本分类器开始。然后在它后面创建第二个分类器，以关注训练数据中第一个分类器出错的实例。该过程继续添加分类器，直到达到模型数量或准确率的极限。
在 AdaBoostM1(自适应升压)算法中，在 Weka 中提供了升压。
- 在算法部分点击添加新的……。
- 点击选择按钮。
- 点击元选择下的 AdaBoostM1 。
- 点击分类器的选择按钮，选择树部分下的 J48 ，点击选择按钮。
- 点击 AdaBoostM1 配置上的确定按钮。
制袋材料
bagging(Bootstrap aggregation)是一种集成方法，它创建训练数据集的单独样本，并为每个样本创建一个分类器。这些多个分类器的结果然后被组合(例如平均或多数投票)。诀窍是训练数据集的每个样本都是不同的，给每个被训练的分类器一个微妙不同的焦点和问题视角。
- 在算法部分点击添加新的……。
- 点击选择按钮。
- 点击“元”选项下的“装袋”。
- 点击分类器的选择按钮，选择树部分下的 J48 ，点击选择按钮。
- 点击装袋配置上的确定按钮。
混合
混合是一种集成方法，其中对训练数据准备多个不同的算法，并准备一个元分类器，该分类器学习如何利用每个分类器的预测，并对看不见的数据做出准确的预测。
在 Weka 中，混合被称为堆叠(在堆叠概括方法之后)。我们将使用两个分类器(J48 和 IBk)添加堆叠，并使用逻辑回归作为元分类器。
J48 和 IBk (k 近邻)是非常不同的算法，我们希望在我们的混合中包含“好的”(可以对问题做出有意义的预测)和多种多样(对问题有不同的观点，进而做出不同的有用预测)的算法。逻辑回归是一个很好的可靠和简单的方法来学习如何结合这两种方法的预测，并且非常适合这个二分类问题，因为它本身会产生二元输出。
配置并将混合 J48 和 IBk 的堆叠算法添加到 Weka 实验者。
- 在算法部分点击添加新的……。
- 点击选择按钮。
- 点击元选择下的叠加。
- 点击元分类器的选择按钮，在功能部分选择物流，点击选择按钮。
- 点击“分类器”的值(算法名，其实是一个按钮)。
- 点击归零，点击删除按钮。
- 点击分类器的选择按钮，选择树部分下的 J48 ，点击关闭按钮。
- 点击分类器的选择按钮，在惰性部分选择 IBk ，点击关闭按钮。
- 单击“ X ”关闭算法选择器。
- 点击装袋配置上的确定按钮。
4.运行实验
点击屏幕顶部的“运行”标签。
该选项卡是运行当前配置实验的控制面板。
点击大的开始按钮开始实验，观看日志和状态部分，关注进展情况。
5.查看结果
点击屏幕顶部的“分析”标签。
这将打开实验结果分析面板。
算法等级
我们首先想知道的是哪种算法是最好的。我们可以通过给定算法击败其他算法的次数来对算法进行排名。
- 点击测试基地的选择按钮，选择排名。
- 现在点击执行测试按钮。
排名表显示了每种算法相对于数据集中所有其他算法的统计显著优势。一次胜利意味着比另一种算法的准确率更高的准确率，并且差异具有统计学意义。
在 Weka 实验器中分析结果时的算法排名
我们可以看到，AdaBoostM1 版本的 J48 排名最高，与其他算法相比取得了 2 次重大胜利。我们还可以看到 Stacking 和普通老 J48 排名最低。J48 排名靠后是一个好的迹象，这表明至少一些集成方法提高了问题的准确性。
算法准确率
接下来我们想知道算法取得了什么表现。
- 点击测试基地的选择按钮，在列表中选择 J48 算法，点击选择按钮。
- 单击“显示标准”旁边的复选框。偏差”。
- 现在点击执行测试按钮。
Weka 实验者的算法平均准确率和统计意义。
我们可以看到，AdaBoostM1 算法实现了 93.05% (+/- 3.92%)的分类准确率。我们可以看到，这个值比 J48 高 89.74% (+/- 4.38%)。我们可以在表中的 J48 准确率旁边看到一个“*”，这表明增强的 J48 算法之间的差异是有意义的(具有统计显著性)。
我们还可以看到，AdaBoostM1 算法在 92.40% (+/- 4.40%)时获得了高于 Bagging 的值，但我们没有看到一点“*”，这表明差异没有意义(没有统计意义)。
摘要
在这篇文章中，你发现了如何在 Weka 中用一个数据集和一个算法的三个集成来配置机器学习实验。您发现了如何使用 Weka 实验者来使用集成方法提高数据集上机器学习算法的准确性，以及如何分析结果。
如果你已经走了这么远，为什么不呢:
- 看看能不能用其他的集成方法，得到更好的效果。
- 看看你是否可以使用不同的配置为装袋，增压或混合算法，并获得更好的结果。
如何在 Weka 中加载 CSV 机器学习数据
原文：https://machinelearningmastery.com/load-csv-machine-learning-data-weka/
最后更新于 2020 年 12 月 10 日
在开始建模之前，您必须能够加载数据。
在这篇文章中，您将发现如何在 Weka 中加载您的 CSV 数据集。看完这篇文章，你会知道:
- 关于 ARFF 文件格式以及它是如何用 Weka 表示数据的默认方式。
- 如何在 Weka 浏览器中加载 CSV 文件并将其保存为 ARFF 格式。
- 如何在 ArffViewer 工具中加载 CSV 文件并将其保存为 ARFF 格式。
本教程假设您已经安装了 Weka。
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
我们开始吧。
如何在 Weka 加载 CSV 机器学习数据
图片由泰利斯提供，保留部分权利。
如何谈论 Weka 中的数据
机器学习算法主要设计用于数字阵列。
这被称为表格或结构化数据，因为它是数据在电子表格中的外观，由行和列组成。
Weka 在描述数据时有一个特定的以计算机科学为中心的词汇:
- 实例:一行数据被称为实例，就像问题域中的实例或观察一样。
- 属性:一列数据被称为特征或属性，就像观测的特征一样。
每个属性可以有不同的类型，例如:
- 实数为 1.2 这样的数值。
- 整数表示没有小数部分的数值，如 5。
- 名词性表示“狗”和“猫”等类别数据。
- 字符串为单词列表，如这句话。
在分类问题上，输出变量必须是标称的。对于回归问题，输出变量必须是真实的。
Weka 的数据
Weka 更喜欢以 ARFF 格式加载数据。
ARFF 是代表属性关系文件格式的缩写。它是 CSV 文件格式的扩展，其中使用了一个标题，提供了有关列中数据类型的元数据。
例如，CSV 格式的经典鸢尾花数据集的前几行如下所示:
5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
4.7,3.2,1.3,0.2,Iris-setosa
4.6,3.1,1.5,0.2,Iris-setosa
5.0,3.6,1.4,0.2,Iris-setosa
ARFF 格式的相同文件如下所示:
@RELATION iris
@ATTRIBUTE sepallength REAL
@ATTRIBUTE sepalwidth REAL
@ATTRIBUTE petallength REAL
@ATTRIBUTE petalwidth REAL
@ATTRIBUTE class {Iris-setosa,Iris-versicolor,Iris-virginica}
@DATA
5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
4.7,3.2,1.3,0.2,Iris-setosa
4.6,3.1,1.5,0.2,Iris-setosa
5.0,3.6,1.4,0.2,Iris-setosa
您可以看到指令以 at 符号(@)开始，并且有一个用于数据集名称的指令(例如@RELATION iris)，有一个用于定义每个属性的名称和数据类型的指令(例如@ATTRIBUTE sepallength REAL)，还有一个用于指示原始数据开始的指令(例如@DATA)。
ARFF 文件中以百分比符号(%)开头的行表示注释。
原始数据部分中带有问号符号(？)表示未知或缺失的值。该格式支持数字和分类值，如上面的 iris 示例，但也支持日期和字符串值。
根据您安装的 Weka，您的 Weka 安装目录中的 data/ 子目录下可能有也可能没有一些默认数据集。这些与 Weka 一起分发的默认数据集是 ARFF 格式的，并且具有。arff 文件扩展名。
在 ARFF 浏览器中加载 CSV 文件
您的数据不太可能是 ARFF 格式。
事实上，它更有可能是逗号分隔值(CSV)格式。这是一种简单的格式，其中数据以行和列的形式排列，逗号用于分隔行中的值。引号也可以用于包围值，尤其是当数据包含带空格的文本字符串时。
CSV 格式很容易从微软 Excel 导出，所以一旦您可以将数据导入 Excel，就可以轻松地将其转换为 CSV 格式。
Weka 提供了一个方便的工具来加载 CSV 文件并保存在 ARFF。您只需要对数据集执行一次此操作。
使用下面的步骤，您可以将数据集从 CSV 格式转换为 ARFF 格式，并与 Weka 工作台一起使用。如果手边没有 CSV 文件，可以使用鸢尾花数据集。从 UCI 机器学习资源库 ( 直接链接)下载文件，保存到当前工作目录为 iris.csv 。
1.启动 Weka 选择器。
Weka 图形用户界面选择器截图
2.单击菜单中的“工具”打开 ARFF 查看器，并选择“自动查看器”。
3.您将看到一个空的 ARFF 查看器窗口。
Weka·ARFF 观众
4.通过单击“文件”菜单并选择“打开”，在 ARFF 查看器中打开您的 CSV 文件。导航到当前工作目录。将“文件类型:”过滤器更改为“CSV 数据文件(*。csv)"。选择您的文件，然后单击“打开”按钮。
在 ARFF 浏览器中加载 CSV
5.您应该会看到一个加载到 ARFF 查看器中的 CSV 文件示例。
6.通过单击“文件”菜单并选择“另存为…”，以 ARFF 格式保存数据集。输入扩展名为. arff 的文件名，然后单击“保存”按钮。
您现在可以加载已保存的。arff 文件直接进入 Weka。
注意，ARFF 查看器提供了在保存之前修改数据集的选项。例如，您可以更改值、更改属性的名称以及更改它们的数据类型。
强烈建议您指定每个属性的名称，因为这将有助于以后的数据分析。此外，确保每个属性的数据类型都是正确的。
在 Weka 浏览器中加载 CSV 文件
您也可以直接在 Weka Explorer 界面中加载您的 CSV 文件。
如果你赶时间，想快速测试一个想法，这很方便。
本节向您展示了如何在 Weka 资源管理器界面中加载您的 CSV 文件。如果没有要加载的 CSV 数据集，您可以再次使用 iris 数据集进行练习。
1.启动 Weka 图形用户界面选择器。
2.通过单击“浏览器”按钮启动 Weka 浏览器。
Weka 探险家的截图
3.单击“打开文件…”按钮。
4.导航到当前工作目录。将“文件类型”更改为“CSV 数据文件(*)。csv)"。选择您的文件，然后单击“打开”按钮。
您可以直接处理数据。您也可以通过单击“保存”按钮并键入文件名，将数据集保存为 ARFF 格式。
将 Excel 用于其他文件格式
如果您有其他格式的数据，请先将其加载到 Microsoft Excel 中。
使用不同的分隔符或固定宽度字段以另一种格式(如 CSV)获取数据是很常见的。Excel 有强大的工具来加载各种格式的表格数据。使用这些工具，首先将数据加载到 Excel 中。
将数据加载到 Excel 后，可以将其导出为 CSV 格式。然后，您可以在 Weka 中使用它，或者直接使用，或者首先将其转换为 ARFF 格式。
资源
以下是一些额外的资源，当您在 Weka 中处理 CSV 数据时，这些资源可能会很有用。
摘要
在这篇文章中，你发现了如何将你的 CSV 数据加载到 Weka 中进行机器学习。
具体来说，您了解到:
- 关于 ARFF 文件格式以及 Weka 如何使用它来表示机器学习的数据集。
- 如何使用 ARFF 查看器加载您的 CSV 数据并将其保存为 ARFF 格式。
- 如何在 Weka Explorer 中直接加载你的 CSV 数据并用于建模。
你对在 Weka 加载数据或这篇文章有什么问题吗？在评论中提问，我会尽力回答。
使用关联规则学习的菜篮子分析
原文：https://machinelearningmastery.com/market-basket-analysis-with-association-rule-learning/
最后更新于 2021 年 9 月 15 日
数据挖掘的承诺是算法将处理数据，并找到您可以在业务中利用的有趣模式。
这个承诺的范例是市场篮子分析(维基百科称之为亲和力分析)。给定一堆交易记录，发现可以在商店中利用的有趣的购买模式，例如优惠和产品布局。
在这篇文章中，你将在 Weka 中使用关联规则学习来学习一个市场篮子分析教程。如果您按照逐步说明进行操作，您将在不到 5 分钟的时间内对销售点数据进行市场篮子分析。
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
我们开始吧。
菜篮子分析
图片由健康量表提供，保留部分权利。
关联规则学习
我曾经为一家初创公司做过咨询工作，调查 SaaS 应用程序中的客户行为。我们对表明从免费账户到付费账户的流失或转换的行为模式感兴趣。
我花了几周的时间浏览数据，寻找相关性和图表。我想出了一堆规则，指出了结果，并提出了可能的干预措施的想法，以影响这些结果。
我想出了这样的规则:“用户在 y 天内创建 x 个小部件并登录 n 次，然后他们将转换”。我将数字归因于规则，例如支持(所有记录中与规则匹配的记录数量)和提升(使用规则预测转换时预测准确性的%增长)。
直到我发表了报告之后，我才意识到我犯了一个多么巨大的错误。我曾经手工执行过关联规则学习，当时有现成的算法可以帮我完成这项工作。
我分享这个故事是为了让它留在你的脑海里。如果您正在筛选大型数据集以寻找感兴趣的模式，那么关联规则学习是您应该使用的一套方法。
1.启动 Weka 浏览器
在之前的教程中，我们已经学习了运行分类器、设计和运行实验、算法调整和集成方法。如果你需要下载和安装 Weka 的帮助，请参考这些以前的帖子。
Weka 图形用户界面选择器
启动 Weka 探索者。
2.加载超市数据集
在 Weka 安装的“数据”目录中，Weka 附带了许多真实数据集。这非常方便，因为您可以探索和实验这些众所周知的问题，并了解 Weka 中供您使用的各种方法。
加载超市数据集(数据/超市. arff )。这是一个销售点信息数据集。数据是名义上的，每个实例代表一个超市的客户交易、购买的产品和涉及的部门。网上关于这个数据集的信息不多，不过你可以从收集数据的个人看到这个评论(“使用 supermarket.arff 进行学术研究的问题”)。
在 Weka 浏览器中加载的超市数据集
数据包含 4，627 个实例和 217 个属性。数据被反规格化。每个属性都是二进制的，要么有值(“ t ”为真)，要么没有值(“？“为失踪”)。有一个名为“total”的名义类属性，它指示事务是小于$100(低)还是大于$100(高)。
我们对为 total 创建预测模型不感兴趣。相反，我们感兴趣的是哪些商品是一起购买的。我们有兴趣在这些数据中找到有用的模式，这些模式可能与预测的属性相关，也可能不相关。
3.发现关联规则
单击 Weka 浏览器中的“关联”选项卡。已经选择了先验算法。这是最广为人知的关联规则学习方法，因为它可能是第一种( Agrawal 和 Srikant 在 1994 年)并且非常高效。
原则上，算法很简单。它建立属性值(项目)集，最大化可以解释的实例数量(数据集的覆盖范围)。通过项目空间的搜索与属性选择和子集搜索面临的问题非常相似。
点击开始按钮，在数据集上运行 Apriori。
4.分析结果
关联规则学习的真正工作是解释结果。
Weka 先验关联规则学习的结果
从 Associator 输出窗口可以看到，算法呈现了从超市数据集学习到的 10 条规则。默认情况下，该算法被配置为停止在 10 个规则，您可以单击算法名称，并通过更改“规则数”值来配置它，以查找和报告更多规则。
这些规则发现了:
- 饼干=t 冷冻食品=t 水果=t 总量=高 788 == >面包和蛋糕=t 723 conf:(0.92)
- 烘焙需求=t 饼干=t 水果=t 总量=高 760 == >面包和蛋糕=t 696 conf:(0.92)
- 烘焙需求=t 冷冻食品=t 水果=t 总量=高 770 == >面包和蛋糕=t 705 conf:(0.92)
- 饼干=t 水果=t 蔬菜=t 总数=高 815 == >面包和蛋糕=t 746 conf:(0.92)
- 派对零食=t 水果=t 总数=高 854 == >面包和蛋糕=t 779 conf:(0.91)
- 饼干=t 冷冻食品=t 蔬菜=t 总量=高 797 == >面包和蛋糕=t 725 conf:(0.91)
- 烘焙需求=t 饼干=t 蔬菜=t 总量=高 772 == >面包和蛋糕=t 701 conf:(0.91)
- 饼干=t 水果=t 总数=高 954 == >面包和蛋糕=t 866 conf:(0.91)
- 冷冻食品=t 水果=t 蔬菜=t 总量=高 834 == >面包和蛋糕=t 757 conf:(0.91)
- 冷冻食品=t 水果=t 总量=高 969 == >面包和蛋糕=t 877 conf:(0.91)
很酷，对吧！
您可以看到规则以先行= >后续格式呈现。与先行词相关联的数字是数据集中的绝对覆盖范围(在本例中是 4，627 个可能总数中的一个数字)。结果旁边的数字是匹配前因和结果的实例的绝对数量。末尾括号中的数字是对规则的支持(先行数除以匹配的结果数)。您可以看到，在选择规则时使用了 91%的截止值，在“关联者输出”窗口中提到了这一点，并在中指出没有任何规则的覆盖率小于 0.91。
我不想把 10 条规则都过一遍，那太麻烦了。以下是一些观察结果:
- 我们可以看到，所有呈现的规则都有一个“面包和蛋糕”的结果。
- 所有提交的规则都表明交易总额很高。
- “饼干”和“冷冻食品”出现在许多规定中。
你必须非常小心地解释关联规则。它们是关联(认为相互关联)，不是必然的因果关系。此外，短先行词可能比长先行词更健壮，长先行词更脆弱。
增加篮筐尺寸
图片由 goosmurf 提供，保留部分权利。
例如，如果我们对总额感兴趣，我们可能想说服购买饼干、冷冻食品和水果的人购买面包和蛋糕，这样他们就可以获得较高的交易总额(规则#1)。这听起来似乎有道理，但却是有缺陷的推理。产品组合不会导致高总额，它只与高总额相关联。除了规则中的项目外，这 723 笔交易可能还有大量随机项目。
测试可能有趣的是对收集相关商品所需的商店路径进行建模，并查看对该路径的更改(更短、更长、显示的优惠等)是否对交易规模或购物篮规模有影响。
摘要
在这篇文章中，你发现了从大型数据集中自动学习关联规则的能力。您了解到使用像 Apriori 这样的算法比手工推导规则要有效得多。
您在 Weka 执行了第一次市场篮子分析，并了解到真正的工作是在结果分析中。你发现在解释规则时需要仔细注意细节，关联(相关性)与因果关系不同。
如何在 Weka 完成多类分类项目
原文：https://machinelearningmastery.com/multi-class-classification-tutorial-weka/
最后更新于 2019 年 8 月 22 日
Weka 机器学习工作台非常容易使用，通过机器学习项目工作会非常有趣。
在这篇文章中，你将使用 Weka 端到端地完成你的第一个机器学习项目。这个温和的项目工作入门将把你在 Weka 完成机器学习项目时需要完成的关键步骤联系在一起。
完成本项目后，您将知道:
- 如何分析数据集并假设可以使用的数据准备和建模算法。
- 如何在一个问题上抽查一套标准的机器学习算法
- 如何呈现最终结果？
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
我们开始吧。
Weka
多类分类教程 Johan Neven 摄，保留部分权利。
教程概述
本教程将逐步指导您完成机器学习项目所需的关键步骤。
我们将通过以下流程开展工作:
- 加载数据集。
- 分析数据集。
- 评估计法。
- 展示结果。
您可以将此作为流程中最少步骤的模板，使用 Weka 完成您自己的机器学习项目。
1.加载数据集
在本教程中，我们将使用鸢尾花类别数据集。
虹膜数据集中的每个实例都描述了鸢尾花的测量值，任务是预测观察属于哪 3 种鸢尾花。有 4 个数值输入变量，单位相同，尺度一般相同。您可以在 UCI 机器学习资源库中了解更多数据集。最高的结果大约是 96%的准确率。
1.打开 Weka 图形用户界面选择器。
Weka 图形用户界面选择器
2.单击“浏览器”按钮打开 Weka 浏览器。
3.点击“打开文件…”按钮，导航至数据/ 目录，选择 iris.arff 。单击“打开”按钮。
数据集现在被加载到 Weka 中。
Weka 加载鸢尾花数据集
2.分析数据集
在开始建模之前，查看您的数据非常重要。
回顾每个属性的分布和属性之间的交互可能会对我们可以使用的特定数据转换和特定建模技术有所启发。
汇总统计
在“当前关系”窗格中查看数据集的详细信息。我们可以注意到一些事情:
- 数据集被称为 iris。
- 有 150 个例子。如果我们稍后使用 10 倍交叉验证来评估计法，那么每个折叠将由 15 个实例组成，这是相当小的。我们可能想考虑使用 30 个实例的 5 倍来代替。
- 有 5 个属性，4 个输入和 1 个输出变量。
有少量属性，我们可以使用特征选择方法进一步研究。
单击“属性”窗格中的每个属性，并查看“选定属性”窗格中的汇总统计信息。
我们可以注意到一些关于数据的事实:
- 任何属性都没有缺失值。
- 所有输入都是数字，其值在大约 0 到大约 8 之间的相同范围内。
- 最后一个属性是名为 class 的输出变量，它是标称的，有三个值。
- 这些类是平衡的，这意味着每个类中有相同数量的实例。如果它们不平衡，我们可能要考虑平衡它们。
我们可能会从数据的规范化或标准化中看到一些好处。
属性分布
单击“全部可视化”按钮，查看每个属性的图形分布。
Weka 单变量属性分布图
我们可以注意到一些关于数据形状的事情:
- 我们可以看到每个属性上每个类值的重叠但不同的分布。这是一个好的迹象，因为我们可能可以分开上课。
- 看起来 sepalwidth 有一个类似高斯的分布。如果我们有更多的数据，也许它会更高斯。
- 看起来其他 3 个输入属性具有近似高斯分布，在分布的低端有偏斜或大量观察值。同样，这让我认为，如果我们有更多数量级的例子，数据可能是高斯的。
- 我们还获得了一个视觉指示，表明这些类是平衡的。
属性交互
单击“可视化”选项卡，让我们查看属性之间的一些交互。
- 增加窗口大小，以便所有图都可见。
- 将“点大小”增加到 3，使点更容易看到。
- 单击“更新”按钮应用更改。
Weka 属性散点图矩阵
查看输入变量的图表，我们可以看到散点图上的类之间有很好的分离。例如，花瓣宽度对分离强度和花瓣宽度对分离强度就是很好的例子。
这表明线性方法，可能还有决策树和基于实例的方法可以很好地解决这个问题。它还建议我们可能不需要花太多时间调整或使用先进的建模技术和集成。这可能是一个简单的建模问题。
3.评估计法
让我们设计一个小实验来评估这个问题的一套标准分类算法。
1.关闭 Weka 浏览器。
2.单击 Weka 图形用户界面选择器上的“实验者”按钮，启动 Weka 实验环境。
Weka 实验环境
3.点击“新建”开始新的实验。
4.在“实验类型”窗格中，将“折叠数”从“10”更改为“5”。
5.在“数据集”窗格中，单击“添加新的…”并在您的 Weka 安装目录中选择 data/iris.arff 。
6.在“算法”窗格中，单击“添加新的…”并添加以下 8 种多类分类算法:
- 规则。零
- 贝叶斯。天真的贝叶斯
- 功能。物流的
- 功能。高年资军医(senior medical officer)
- 放松，IBk
- 规则。部分
- 树木。REPTree
- 树木。J48
7.在算法列表中选择 IBK，然后单击“编辑所选…”按钮。
8.将“KNN”从“1”更改为“3”，然后单击“确定”按钮保存设置。
Weka 设计算法比较实验
9.点击“运行”打开“运行”标签，点击“开始”按钮运行实验。实验应该在几秒钟内完成。
Weka 执行 Weka 算法比较实验
10.点击“分析”打开“分析”标签。单击“实验”按钮加载实验结果。
Weka 负载算法对比实验结果
11.单击“执行测试”按钮执行成对测试，将所有结果与 ZeroR 的结果进行比较。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 0 -stddev-width 0 -sig-width 0 -count-width 5 -print-col-names -print-row-names -enum-col-names"
Analysing: Percent_correct
Datasets: 1
Resultsets: 7
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 8:02 AM
Dataset (1) rules.Ze | (2) bayes (3) funct (4) funct (5) lazy. (6) trees (7) trees
----------------------------------------------------------------------------------------------------
iris (50) 33.33 | 95.47 v 96.33 v 96.33 v 95.20 v 94.27 v 94.53 v
----------------------------------------------------------------------------------------------------
(v/ /*) | (1/0/0) (1/0/0) (1/0/0) (1/0/0) (1/0/0) (1/0/0)
Key:
(1) rules.ZeroR '' 48055541465867954
(2) bayes.NaiveBayes '' 5995231201785697655
(3) functions.Logistic '-R 1.0E-8 -M -1 -num-decimal-places 4' 3932117032546553727
(4) functions.SMO '-C 1.0 -L 0.001 -P 1.0E-12 -N 0 -V -1 -W 1 -K \"functions.supportVector.PolyKernel -E 1.0 -C 250007\" -calibrator \"functions.Logistic -R 1.0E-8 -M -1 -num-decimal-places 4\"' -6585883636378691736
(5) lazy.IBk '-K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(6) trees.REPTree '-M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0' -9216785998198681299
(7) trees.J48 '-C 0.25 -M 2' -217733168393644444
我们可以看到所有的模特都有技巧。每个模型的得分都优于零，差异具有统计学意义。
结果表明，逻辑回归和 SVM 达到最高的准确性。如果我们要在两者之间进行选择，我们会选择逻辑回归，如果没有其他原因，这是一个简单得多的模型。让我们将所有结果与作为测试基础的逻辑回归结果进行比较。
12.单击“测试基地”的“选择”，选择“功能”。逻辑”并单击“选择”按钮选择新的测试基地。再次单击“执行测试”按钮执行新的分析。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 2 -stddev-width 2 -sig-width 1 -count-width 5 -print-col-names -print-row-names -enum-col-names"
Analysing: Percent_correct
Datasets: 1
Resultsets: 7
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 8:05 AM
Dataset (3) function | (1) rules (2) bayes (4) funct (5) lazy. (6) trees (7) trees
----------------------------------------------------------------------------------------------------
iris (50) 96.33 | 33.33 * 95.47 96.33 95.20 94.27 94.53
----------------------------------------------------------------------------------------------------
(v/ /*) | (0/0/1) (0/1/0) (0/1/0) (0/1/0) (0/1/0) (0/1/0)
Key:
(1) rules.ZeroR '' 48055541465867954
(2) bayes.NaiveBayes '' 5995231201785697655
(3) functions.Logistic '-R 1.0E-8 -M -1 -num-decimal-places 4' 3932117032546553727
(4) functions.SMO '-C 1.0 -L 0.001 -P 1.0E-12 -N 0 -V -1 -W 1 -K \"functions.supportVector.PolyKernel -E 1.0 -C 250007\" -calibrator \"functions.Logistic -R 1.0E-8 -M -1 -num-decimal-places 4\"' -6585883636378691736
(5) lazy.IBk '-K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(6) trees.REPTree '-M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0' -9216785998198681299
(7) trees.J48 '-C 0.25 -M 2' -217733168393644444
我们现在看到了一个非常不同的故事。虽然逻辑分析的结果看起来更好，但分析表明，这些结果与所有其他算法的结果之间的差异在统计上并不显著。
从这里，我们可以选择一个基于其他标准的算法，如可理解性或复杂性。从这个角度来看，逻辑回归和朴素贝叶斯是很好的选择。
我们还可以寻求进一步改进这些算法中的一个或多个的结果，并看看我们是否能够实现显著的改进。如果我们将“显著性”更改为 0.50 的较小约束值，我们可以看到树和 KNN 算法开始消失。这表明我们可以花更多的时间在剩下的方法上。将“显著性”改回“0.05”。
让我们选择坚持逻辑回归。我们可以收集一些数字，用来描述模型在看不见的数据上的表现。
13.选中“显示标准”。偏差”来表示准确度分数的标准偏差。
14.单击“显示的列”的“选择”按钮，然后选择“功能”。物流”，点击“选择”接受选择。这将只显示逻辑回归算法的结果。
15.单击“执行测试”重新运行分析。
我们现在有了一个可以用来描述我们模型的最终结果。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -V -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 2 -stddev-width 2 -sig-width 1 -count-width 5 -show-stddev -print-col-names -print-row-names -enum-col-names"
Analysing: Percent_correct
Datasets: 1
Resultsets: 7
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 8:12 AM
Dataset (3) functions.Logist
----------------------------------------------
iris (50) 96.33(3.38) |
----------------------------------------------
(v/ /*) |
Key:
(3) functions.Logistic '-R 1.0E-8 -M -1 -num-decimal-places 4' 3932117032546553727
我们可以看到，模型对未知数据的估计准确率为 96.33%，标准偏差为 3.38%。
4.最终确定模型并展示结果
我们可以根据所有训练数据创建模型的最终版本，并将其保存到文件中。
1.关闭 Weka 实验环境。
2.打开 Weka Explorer，加载数据/iris.arff 数据集。
3.单击分类选项卡。
4.选择功能。逻辑算法。
5.将“测试选项”从“交叉验证”更改为“使用训练集”。
6.单击“开始”按钮创建最终模型。
基于整个训练数据集的 Weka 训练最终模型
7.右键单击“结果列表”中的结果项，然后选择“保存模型”。选择一个合适的位置，并输入一个合适的名称，如“iris-logistics”为您的模型。
这个模型可以在以后加载，并用于预测新的花朵尺寸。
我们可以使用上一节中收集的模型准确率的平均值和标准偏差来帮助量化模型在未知数据上的估计准确率的预期可变性。
例如，我们知道 95%的模型准确率将落在平均模型准确率的两个标准偏差内。或者，以我们可以向其他人解释的方式重述，我们通常可以预期模型在未看到的数据上的表现将为 96.33%±2 * 3.38 或 6.76，或者在 87.57%和 100%之间准确。
你可以在维基百科名为68–95–99.7 规则的页面中了解更多关于使用高斯分布的平均值和标准差的信息。
摘要
在这篇文章中，您使用 Weka 机器学习工作台端到端地完成了您的第一个机器学习项目。
具体来说，您了解到:
- 如何分析数据集，并建议可能有用的特定数据转换和建模技术。
- 如何抽查问题上的一套算法并分析其结果？
- 如何最终确定模型，以便对新数据进行预测，并根据看不见的数据显示模型的估计准确率。
你对在 Weka 运行机器学习项目或这篇文章有什么问题吗？在评论中提出你的问题，我会尽力回答。
如何在 Weka 中规范和标准化你的机器学习数据
原文：https://machinelearningmastery.com/normalize-standardize-machine-learning-data-weka/
最后更新于 2019 年 12 月 11 日
机器学习算法对您正在建模的数据集进行假设。
通常，原始数据由不同比例的属性组成。例如，一个属性可以是千克，另一个属性可以是计数。虽然不是必需的，但是通过仔细选择重新缩放数据的方法，您通常可以提高表现。
在这篇文章中，您将发现如何重新缩放数据，以便所有数据都具有相同的比例。
看完这篇文章你会知道:
- 如何在 0 和 1 之间规范化数值属性。
- 如何标准化您的数字属性，使其具有 0 均值和单位方差。
- 什么时候选择规范化还是标准化。
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
我们开始吧。
- 2018 年 3 月更新:增加了下载数据集的替代链接，因为原件似乎已经被取下来。
预测糖尿病的发作
本例中使用的数据集是皮马印第安人糖尿病发病数据集。
这是一个分类问题，其中每个实例代表一个患者的医疗细节，任务是预测该患者是否会在未来五年内出现糖尿病。
这是一个很好的练习缩放的数据集，因为 8 个输入变量都有不同的缩放，例如患者怀孕次数的计数( preg )和患者体重指数( mass )的计算。
下载数据集并将其放在当前工作目录中。
您也可以在您的 Weka 安装中，在名为 diabetes.arff 的文件中的 data/ 目录下访问该数据集。
Weka 负荷糖尿病数据集
关于 Weka 的数据过滤器
Weka 提供了转换数据集的过滤器。查看支持哪些过滤器并在数据集上使用它们的最好方法是使用 Weka Explorer。
“过滤器”面板允许您选择过滤器。
用于选择数据过滤器的 Weka 过滤器窗格
过滤器分为两种类型:
- 监督过滤器:可以应用，但在某些方面需要用户控制。例如重新平衡一个类的实例。
- 无监督过滤器:可以以无方向的方式应用。例如，将所有值重新缩放到 0 到 1 的范围。
我个人认为这两种过滤器的区分有点武断和混乱。然而，这就是它们的布局。
在这两个组中，过滤器进一步分为属性过滤器和实例过滤器:
- 属性过滤器:对属性或一次一个属性进行操作。
- 实例过滤器:一次对一个实例或一个实例应用一个操作。
这种区别更有意义。
选择过滤器后，其名称将出现在“选择”按钮旁边的框中。
您可以通过单击过滤器的名称来配置过滤器，这将打开配置窗口。您可以更改过滤器的参数，甚至保存或加载过滤器本身的配置。这对于再现性非常重要。
Weka 数据过滤器配置
您可以通过悬停在每个配置选项上并阅读工具提示来了解更多信息。
单击“更多”按钮，您还可以阅读关于过滤器的所有详细信息，包括配置、论文和书籍，以便进一步阅读和了解关于过滤器工作的更多信息。
Weka 数据过滤器更多信息
您可以通过单击“确定”按钮关闭帮助并应用配置。
您可以通过单击过滤器名称旁边的“应用”按钮，将过滤器应用于加载的数据集。
规范化您的数字属性
数据规范化是将一个或多个属性重新缩放到 0 到 1 范围的过程。这意味着每个属性的最大值是 1，最小值是 0。
当您不知道数据的分布或知道分布不是高斯分布(钟形曲线)时，归一化是一种很好的技术。
您可以使用 Weka 对数据集中的所有属性进行规范化，方法是选择“规范化”过滤器并将其应用到数据集中。
您可以使用以下方法来标准化数据集:
1.打开 Weka 浏览器。
2.加载数据集。
Weka 浏览器加载的糖尿病数据集
3.点击“选择”按钮选择一个过滤器并选择无监督。属性。归一化。
Weka 选择标准化数据过滤器
4.单击“应用”按钮来规范化数据集。
5.单击“保存”按钮并键入文件名以保存数据集的规范化副本。
在“选定属性”窗口中查看每个属性的详细信息将使您确信筛选成功，并且每个属性都被重新缩放到 0 到 1 的范围内。
Weka 归一化数据分布
您可以使用其他比例，例如-1 比 1，这在使用支持向量机和 adaboost 时非常有用。
当您的数据具有不同的规模，并且您使用的算法不对数据的分布做出假设时，例如 k 近邻和人工神经网络，规范化非常有用。
标准化您的数字属性
数据标准化是重新调整一个或多个属性的过程，使它们的平均值为 0，标准偏差为 1。
标准化假设您的数据具有高斯(钟形曲线)分布。严格来说，这并不一定是真的，但是如果您的属性分布是高斯分布，该技术会更有效。
通过选择标准化过滤器并将其应用于数据集，您可以使用 Weka 标准化数据集中的所有属性。
您可以使用以下方法来标准化数据集:
1.打开 Weka 浏览器
2.加载数据集。
3.单击“选择”按钮选择一个过滤器，然后选择无监督。属性。标准化
Weka 选择标准化数据过滤器
4.单击“应用”按钮来规范化数据集。
5.单击“保存”按钮并键入文件名以保存数据集的标准化副本。
在“选定属性”窗口中查看每个属性的详细信息将使您确信筛选是成功的，并且每个属性的平均值为 0，标准偏差为 1。
Weka 标准化数据分发
当您的数据具有不同的标度，并且您使用的算法确实假设您的数据具有高斯分布时，例如线性回归、逻辑回归和线性判别分析，标准化非常有用。
摘要
在这篇文章中，你发现了如何在 Weka 中重新缩放数据集。
具体来说，您了解到:
- 如何将数据集规范化到 0 到 1 的范围。
- 如何标准化你的数据，使平均值为 0，标准差为 1。
- 何时使用规范化和标准化。
你对你的数据或这篇文章有什么疑问吗？在评论中提问，我会尽力回答。
如何在 Weka 中用机器学习数据执行特征选择
原文：https://machinelearningmastery.com/perform-feature-selection-machine-learning-data-weka/
最后更新于 2019 年 12 月 13 日
原始机器学习数据包含多种属性，其中一些与做出预测相关。
您如何知道使用哪些功能和删除哪些功能？在数据中选择特征来模拟问题的过程称为特征选择。
在这篇文章中，你将发现如何在 Weka 中用你的机器学习数据进行特征选择。
看完这篇文章你会知道:
- 关于处理机器学习问题时特征选择的重要性。
- Weka 平台如何支持功能选择。
- 如何在数据集上使用 Weka 中各种不同的特征选择技术。
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
我们开始吧。
- 2018 年 3 月更新:增加了下载数据集的替代链接，因为原件似乎已经被取下来。
如何使用 Weka
中的机器学习数据执行特征选择图片作者: Peter Gronemann ，版权所有。
预测糖尿病的发作
本例中使用的数据集是皮马印第安人糖尿病发病数据集。
这是一个分类问题，其中每个实例代表一个患者的医疗细节，任务是预测该患者是否会在未来五年内出现糖尿病。
您可以在此了解有关数据集的更多信息:
您也可以在您的 Weka 安装中，在名为 diabetes.arff 的文件中的 data/ 目录下访问该数据集。
Weka 的特色选择
Weka 支持许多功能选择技术。
开始探索 Weka 功能选择的一个好地方是在 Weka 浏览器中。
- 打开 Weka 图形用户界面选择器。
- 单击“资源管理器”按钮启动资源管理器。
- 打开皮马印第安人数据集。
- 单击“选择属性”选项卡访问功能选择方法。
Weka 功能选择
特征选择分为两部分:
- 属性求值器
- 搜索方法。
每个部分都有多种技术可供选择。
属性赋值器是一种在输出变量(例如类)的上下文中对数据集中的每个属性(也称为列或要素)进行求值的技术。搜索方法是一种尝试或导航数据集中不同属性组合的技术，目的是获得所选要素的简短列表。
一些属性评估技术需要使用特定的搜索方法。例如，下一节中使用的相关性属性评估技术只能与排名搜索方法一起使用，该方法评估每个属性并按排名顺序列出结果。选择不同的属性赋值器时，界面可能会要求您将搜索方法更改为与所选技术兼容的方法。
Weka 功能选择警报
属性评估器和搜索方法技术都可以配置。选择后，单击该技术的名称以获取其配置详细信息。
Weka 功能选择配置
单击“更多”按钮，获取有关功能选择技术和配置参数的更多文档。将鼠标光标悬停在配置参数上可获得包含更多详细信息的工具提示。
Weka 功能选择更多信息
现在我们知道了如何在 Weka 中访问特征选择技术，让我们看看如何在我们选择的标准数据集上使用一些流行的方法。
基于相关性的特征选择
选择数据集中最相关属性的一种流行技术是使用相关性。
相关性在统计学中更正式地称为皮尔逊相关系数。
您可以计算每个属性和输出变量之间的相关性，并只选择那些具有中到高正相关性或负相关性(接近-1 或 1)的属性，并删除那些低相关性(值接近零)的属性。
Weka 通过要求使用 Ranker 搜索方法的 CorrelationAttributeEval 技术支持基于相关性的特征选择。
在我们的皮马印第安人数据集上运行这一结果表明，一个属性(plas)与输出类的相关性最高。它也暗示了一系列具有适度相关性的属性(体重、年龄、孕龄)。如果我们使用 0.2 作为相关属性的截止值，那么剩下的属性可能会被移除(pedi、insu、skin 和 pres)。
基于 Weka 相关性的特征选择方法
基于信息增益的特征选择
另一种流行的特征选择技术是计算信息增益。
您可以为输出变量的每个属性计算信息增益(也称为熵)。条目值从 0(无信息)到 1(最大信息)不等。那些贡献更多信息的属性将具有更高的信息增益值，并且可以被选择，而那些没有添加太多信息的属性将具有更低的分数，并且可以被移除。
Weka 支持使用信息增益属性评估器通过信息增益选择特征。像上面的相关技术一样，必须使用 Ranker 搜索方法。
在我们的皮马印第安人身上运行这项技术，我们可以看到一个属性比所有其他属性贡献更多的信息。如果我们使用 0.05 的任意截止值，那么我们也将选择质量、年龄和 insu 属性，并从我们的数据集中删除其余的属性。
基于 Weka 信息增益的特征选择方法
基于学习器的特征选择
一种流行的特征选择技术是使用通用但强大的学习算法，并在选择了不同属性子集的数据集上评估计法的表现。
产生最佳表现的子集被视为所选子集。用于评估子集的算法不一定是您打算用来建模您的问题的算法，但是它通常应该快速训练并且功能强大，就像决策树方法一样。
在 Weka 中，这种类型的功能选择受 WrapperSubsetEval 技术支持，并且必须使用 GreedyStepwise 或 BestFirst 搜索方法。如果你能抽出计算时间，最好选择后者。
1.首先选择“WrapperSubsetEval”技术。
2.单击名称“WrapperSubsetEval”打开该方法的配置。
3.单击“分类器”的“选择”按钮，并将其更改为“树”下的 J48。
Weka 包装器功能选择配置
4.单击“确定”接受配置。
5.将“搜索方法”更改为“最佳优先”。
6.单击“开始”按钮评估功能。
在皮马印第安人数据集上运行这种特征选择技术可以从 8 个输入变量中选择 4 个:plas、pres、mass 和 age。
Weka 包装器特征选择方法
在 Weka 中选择属性
回顾这三种技术，我们可以看到所选特征(例如 plas)有一些重叠，但也有差异。
评估机器学习数据集的多个不同“视图”是一个好主意。数据集视图只不过是由给定要素选择技术选择的要素子集。这是你的数据集的副本，你可以很容易地在 Weka。
例如，从上一个特征选择技术的结果来看，假设我们想要创建一个只有以下属性的皮马印第安人数据集视图:plas、pres、mass 和 age:
1.单击“预处理”选项卡。
2.在“属性”选项中，勾选除塑料、压力、质量、年龄和等级属性之外的所有属性。
Weka 选择要从数据集中移除的属性
3.单击“删除”按钮。
4.单击“保存”按钮并输入文件名。
现在，您有了一个新的数据集视图要探索。
从数据集中移除的 Weka 属性
使用什么特征选择技术
您无法知道哪些数据视图将产生最准确的模型。
因此，在您的数据上尝试多种不同的要素选择技术，进而创建数据的多种不同视图是一个好主意。
选择一种好的通用技术，比如决策树，为数据的每个视图建立一个模型。
比较结果，了解哪种数据视图的表现最好。这将给你一个视图的概念，或者更具体地说，给你的学习算法提供最好的问题结构的特性。
摘要
在这篇文章中，您发现了特征选择的重要性，以及如何使用 Weka 对数据进行特征选择。
具体来说，您了解到:
- 如何利用相关性进行特征选择？
- 如何利用信息增益进行特征选择？
- 如何通过在不同的特征子集上训练模型来执行特征选择。
你对 Weka 的功能选择或这篇文章有什么问题吗？在评论中提问，我会尽力回答。
针对机器学习问题的快速脏数据分析
原文：https://machinelearningmastery.com/quick-and-dirty-data-analysis-for-your-machine-learning-problem/
最后更新于 2019 年 8 月 22 日
要很好地理解你正在研究的机器学习问题，你需要密切了解数据。
我个人觉得这一步有时很繁重，只是想继续定义我的测试工具，但我知道它总是会冲出感兴趣的想法和假设来测试。因此，在应用机器学习过程的下一步之前，我使用一个逐步的过程来捕获关于实际数据集的最少数量的观察。
快速和肮脏的数据分析
图片由蒂姆·帕金森提供，保留部分权利
在这篇文章中，你将发现我分析数据集并从给定数据集获得最少观测值(和最少理解)的快速而简单的过程。
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
数据分析
数据分析步骤的目标是通过更好地理解问题数据来增加对问题的理解。
这包括提供多种不同的方式来描述数据，作为一个机会来审查和捕捉可以在以后的实验中测试的观察和假设。
我使用了两种不同的方法来描述给定的数据集:
- 汇总数据:描述数据和数据分布。
- 可视化数据:创建数据的各种图形摘要。
这里的关键是在数据集上创建不同的视角或视图，以便让您对数据有所了解。
1.汇总数据
总结数据就是描述数据的实际结构。我通常使用很多自动化工具来描述像属性分布这样的事情。我喜欢总结的数据的最基本方面是结构和分布。
数据结构
总结数据结构就是描述属性的数量和数据类型。例如，经历这个过程突出了数据准备步骤中的转换思想，用于将属性从一种类型转换为另一种类型(例如实数到序数或序数到二进制)。
该步骤的一些激励性问题包括:
- 有多少属性和实例？
- 每个属性的数据类型是什么(例如，名词、序数、整数、实数等)。)?
数据分布
总结每个属性的分布也可以为数据准备步骤中可能的数据转换提供思路，例如离散化、规范化和标准化的需要和效果。
我喜欢捕捉每个实值属性分布的概要。这通常包括最小值、最大值、中值、模式、平均值、标准偏差和缺失值的数量。
该步骤的一些激励性问题包括:
- 创建每个实值属性的五位数摘要。
- 类属性的值分布如何？
了解类属性(或回归输出变量的平均值)的分布是有用的，因为您可以使用它来定义预测模型的最小准确率。
例如，如果有一个二进制分类问题(2 类)，80%的苹果和 20%的香蕉分布，那么预测器可以预测每个测试实例的“苹果”，并确保达到 80%的准确率。当评估计法时，这是测试线束中所有算法必须击败的最坏情况算法。
此外，如果我有时间或兴趣，我喜欢使用参数(皮尔逊)和非参数(斯皮尔曼)相关系数来生成成对属性相关性的摘要。这可以突出显示可能是要删除的候选属性(彼此高度相关)和其他可能是高度可预测的属性(与结果属性高度相关)。
2.可视化数据
可视化数据是关于创建总结数据的图表，捕获它们并研究它们，以获得可以描述的有趣结构。
你似乎可以创建无限多的图表(尤其是在像 R 这样的软件中)，所以我喜欢保持简单，专注于直方图和散点图。
属性直方图
我喜欢创建所有属性的直方图，并标记类值。我喜欢这个，因为我在学习机器学习的时候经常使用 Weka，它为你做到了这一点。尽管如此，在其他软件如 r 中也很容易做到。
用图形表示离散分布可以快速突出显示可能的分布族(如正态分布或指数分布)以及类值如何映射到这些分布上。
显示类别值的属性直方图
该步骤的一些激励性问题包括:
- 显示了哪些分布族(如果有):
- 映射到类值的属性中有什么明显的结构吗？
成对散点图
散点图在每个轴上绘制一个属性。此外，可以以映射到类值的绘制点的颜色的形式添加第三个轴。可以为所有属性对创建成对散点图。
这些图表可以快速突出属性之间的二维结构(如相关性)以及属性到类值的映射中的跨属性趋势。
显示类别值的成对散点图
该步骤的一些激励性问题包括:
- 展示了哪些有趣的二维结构？
- 属性与类值之间有什么有趣的关系？
摘要
在这篇文章中，你发现了一个数据分析的过程，该过程寻求对数据创建不同的视图，以引出对数据的观察和假设。
使用的两种方法是:
- 汇总数据:描述数据和数据分布。
- 可视化数据:创建数据的各种图形摘要。
如何在 Weka 中浏览回归机器学习项目
原文：https://machinelearningmastery.com/regression-machine-learning-tutorial-weka/
最后更新于 2020 年 12 月 10 日
擅长应用机器学习的最快方法是在端到端项目上练习。
在这篇文章中，你将发现如何在 Weka 中端到端地解决一个回归问题。看完这篇文章你会知道:
- 如何在 Weka 中加载和分析回归数据集？
- 如何创建多个不同的数据转换视图，并对每个视图评估一套算法。
- 如何最终确定并呈现模型的结果，以便对新数据进行预测。
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
我们开始吧。
Weka
逐步回归机器学习项目教程图片由 vagawi 提供，保留部分权利。
教程概述
本教程将指导您完成在 Weka 完成机器学习项目所需的关键步骤。
我们将通过以下步骤开展工作:
- 加载数据集。
- 分析数据集。
- 准备数据集的视图。
- 评估计法。
- 调整算法表现。
- 评估集成算法。
- 展示结果。
1.加载数据集
你的 Weka 安装的数据/ 目录中回归问题的选择比较少。回归是一类重要的预测建模问题。从 UCI 机器学习资源库下载回归问题的免费附加包。
它可从 Weka 网页上的数据集页面获得，并且是列表中的第一个，名为:
- 一个包含 37 个回归问题的 jar 文件，从不同的来源获得
它是一个. jar 文件，是一种压缩的 Java 档案。你应该可以用大多数现代的解压程序来解压。如果您安装了 Java(很可能使用 Weka)，您也可以解压缩。在下载 jar 的目录中，使用以下命令在命令行上手动创建 jar 文件:
jar -xvf datasets-numeric.jar
解压缩文件将创建一个名为 numeric 的新目录，其中包含 37 个 ARFF 本地 Weka 格式的回归数据集。
在本教程中，我们将研究波士顿房价数据集。
在这个数据集中，每个实例描述了波士顿郊区的属性，任务是以千美元为单位预测房价。有 13 个不同尺度的数值输入变量描述郊区的特性。您可以在 UCI 机器学习资源库上了解更多关于该数据集的信息。
- 打开 Weka 图形用户界面选择器
- 单击“浏览器”按钮打开 Weka 浏览器。
- 点击“打开文件…”按钮，导航至数字/ 目录，选择房屋. arff 。单击“打开”按钮。
数据集现在被加载到 Weka 中。
Weka 加载波士顿房价数据集
2.分析数据集
在开始建模之前，查看您的数据非常重要。
回顾每个属性的分布和属性之间的交互可能会对我们可以使用的特定数据转换和特定建模技术有所启发。
汇总统计
在“当前关系”窗格中查看数据集的详细信息。我们可以注意到一些事情:
- 数据集称为住房。
- 有 506 个实例。如果我们稍后使用 10 倍交叉验证来评估计法，那么每个折叠将由大约 50 个实例组成，这很好。
- 共有 14 个属性、13 个输入和 1 个输出变量。
单击“属性”窗格中的每个属性，并查看“选定属性”窗格中的汇总统计信息。
我们可以注意到一些关于数据的事实:
- 任何属性都没有缺失值。
- 除了一个二进制属性之外，所有输入都是数字，并且具有不同范围的值。
- 最后一个属性是名为 class 的输出变量，它是数字。
我们可能会从数据的规范化或标准化中看到一些好处。
属性分布
单击“全部可视化”按钮，查看每个属性的图形分布。
Weka 波士顿房价单变量属性分布
我们可以注意到一些关于数据形状的事情:
- 我们可以看到属性有一系列不同的分布。
- CHAS 属性看起来像二进制分布(两个值)。
- RM 属性看起来像是高斯分布。
我们可能会看到使用像决策树这样的非线性回归方法比使用像线性回归这样的线性回归方法更有好处。
属性交互
单击“可视化”选项卡，让我们查看属性之间的一些交互。
- 将“绘图大小”减小到 50，并调整窗口大小，以便所有绘图都可见。
- 将“点大小”增加到 3，使点更容易看到。
- 单击“更新”按钮应用更改。
Weka 波士顿房价散点图矩阵
纵观这些图表，我们可以看到一些有助于建模的结构化关系，例如 DIS 对 NOX 和 AGE 对 NOX。
我们还可以看到输入属性和输出属性之间的一些结构关系，比如 LSTAT 和 CLASS 以及 RM 和 CLASS。
3.准备数据集视图
在本节中，我们将创建一些不同的数据视图，这样当我们在下一节中评估计法时，我们就可以了解哪些视图通常更擅长将回归问题的结构暴露给模型。
我们首先将创建原始 housing.arff 数据文件的修改副本，然后对数据进行 3 次附加转换。我们将从原始数据集的修改副本创建数据集的每个视图，并将其保存到一个新文件中，以供以后在实验中使用。
修改的副本
CHAS 属性是标称的(二进制)，值为“0”和“1”。
我们想复制原来的 housing.arff 数据文件，把 CHAS 改成数字属性，这样所有输入的属性都是数字。这将有助于数据集的转换和建模。
找到 housing.arff 数据集，并在名为 housing-numeric.arff 的相同目录中创建它的副本。
在文本编辑器中打开这个修改过的文件并向下滚动到定义属性的地方，特别是第 56 行的 CHAS 属性。
Weka 波士顿房价属性数据类型
将 CHAS 属性的定义从:
@attribute CHAS { 0, 1}
到
@attribute CHAS real
CHAS 属性现在是数字的，而不是名义的。这个数据集的修改副本将被用作基线数据集。
带有数字数据类型的 Weka 波士顿房价数据集
标准化数据集
我们将创建的第一个视图是将所有输入属性规范化为 0 到 1 的范围。这可能有利于多种算法，这些算法会受到属性规模的影响，比如回归和基于实例的方法。
- 打开 Weka 浏览器。
- 打开修改后的数值数据集外壳-numeric.arff 。
- 点按“过滤器”面板中的“选择”按钮，然后选择“无监督.属性.规范化”过滤器。
- 单击“应用”按钮应用过滤器。
- 单击“属性”窗格中的每个属性，并查看“选定属性”窗格中的最小值和最大值，以确认它们是 0 和 1。
- 单击“保存…”按钮，导航到合适的目录，并为此转换后的数据集键入合适的名称，例如“ housing-normalize.arff ”。
- 关闭浏览器界面。
Weka 波士顿房价数据集标准化数据过滤器
标准化数据集
我们在前一节中注意到，一些属性具有类似高斯的分布。我们可以重新缩放数据，并通过使用标准化过滤器将这种分布考虑在内。
这将创建一个数据集副本，其中每个属性的平均值为 0，标准差(平均方差)为 1。这可能有利于下一节中假设输入属性为高斯分布的算法，如逻辑回归和朴素贝叶斯。
- 打开 Weka 浏览器。
- 打开修改后的数值数据集外壳-numeric.arff 。
- 点按“过滤器”面板中的“选择”按钮，然后选择“无监督.属性.标准化”过滤器。
- 单击“应用”按钮应用过滤器。
- 单击“属性”窗格中的每个属性，并查看“选定属性”窗格中的平均值和标准偏差值，以确认它们分别为 0 和 1。
- 单击“保存…”按钮，导航到合适的目录，并为此转换后的数据集键入合适的名称，例如“housing-standard . ARFF”。
- 关闭浏览器界面。
Weka 波士顿房价数据集标准化数据过滤器
特征选择
我们不确定是否真的需要所有的属性来进行预测。
在这里，我们可以使用自动特征选择来仅选择数据集中那些最相关的属性。
- 打开 Weka 浏览器。
- 打开修改后的数值数据集外壳-numeric.arff 。
- 单击“过滤器”面板中的“选择”按钮，选择“监督属性选择”过滤器。
- 单击“应用”按钮应用过滤器。
- 单击“属性”窗格中的每个属性，查看所选的 5 个属性。
- 单击“保存…”按钮，导航到合适的目录，并为该转换后的数据集键入合适的名称，例如“住房-特征-选择. arff ”。
- 关闭浏览器界面。
Weka 波士顿房价数据集特征选择数据过滤器
4.评估计法
让我们设计一个实验，根据我们创建的问题的不同观点来评估一套标准的分类算法。
1.单击 Weka 图形用户界面选择器上的“实验者”按钮，启动 Weka 实验环境。
2.点击“新建”开始新的实验。
3.在“实验类型”窗格中，将问题类型从“分类”更改为“回归”。
4.在“数据集”窗格中，单击“添加新项…”并选择以下 4 个数据集:
- 外壳-数字. arff
- 房屋-标准化. arff
- 住房标准化. arff
- 房屋特征选择
5.在“算法”窗格中，单击“添加新的…”并添加以下 8 种多类分类算法:
- 规则。零
- bayes 先生。简单线性回归
- 功能。SMOreg
- 放松，IBk
- 树木。REPTree
6.在算法列表中选择 IBK，然后单击“编辑所选…”按钮。
7.将“KNN”从“1”更改为“3”，然后单击“确定”按钮保存设置。
Weka 波士顿房价算法比较实验设计
8.点击“运行”打开“运行”标签，点击“开始”按钮运行实验。实验应该在几秒钟内完成。
9.点击“分析”打开“分析”标签。单击“实验”按钮加载实验结果。
Weka 波士顿房价数据集负载算法对比实验结果
10.将“比较字段”更改为“均方根误差”。
11.单击“执行测试”按钮，执行成对测试，将所有结果与 ZeroR 的结果进行比较。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 3 -stddev-width 2 -sig-width 1 -count-width 5 -print-col-names -print-row-names -enum-col-names"
Analysing: Root_mean_squared_error
Datasets: 4
Resultsets: 5
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 11:06 AM
Dataset (1) rules.Z | (2) func (3) func (4) lazy (5) tree
---------------------------------------------------------------------------
housing (100) 9.11 | 6.22 * 4.95 * 4.41 * 4.64 *
housing-weka.filters.unsu(100) 9.11 | 6.22 * 4.94 * 4.41 * 4.63 *
housing-weka.filters.unsu(100) 9.11 | 6.22 * 4.95 * 4.41 * 4.64 *
'housing-weka.filters.sup(100) 9.11 | 6.22 * 5.19 * 4.27 * 4.64 *
---------------------------------------------------------------------------
(v/ /*) | (0/0/4) (0/0/4) (0/0/4) (0/0/4)
Key:
(1) rules.ZeroR '' 48055541465867954
(2) functions.SimpleLinearRegression '' 1679336022895414137
(3) functions.SMOreg '-C 1.0 -N 0 -I \"functions.supportVector.RegSMOImproved -T 0.001 -V -P 1.0E-12 -L 0.001 -W 1\" -K \"functions.supportVector.PolyKernel -E 1.0 -C 250007\"' -7149606251113102827
(4) lazy.IBk '-K 3 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(5) trees.REPTree '-M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0' -9216785998198681299
记住，RMSE 越低越好。
这些结果很能说明问题。
首先，我们可以看到所有的算法都优于 ZeroR 的基线技能，并且差异显著(每个分数旁边有一个小“*”。我们还可以看到，对数据进行标准化或规范化对评估计法似乎没有太大好处。
至少对于 IBk 来说，从数据集的选择较少要素视图来看，我们可能会看到一个小的改进。
最后，看起来 IBk (KNN)可能有最低的误差。让我们进一步调查。
12.点击“测试基地”的“选择”按钮，选择懒惰。IBk 算法作为新的测试库。
13.单击“执行测试”按钮重新运行分析。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 2 -stddev-width 2 -sig-width 1 -count-width 5 -print-col-names -print-row-names -enum-col-names"
Analysing: Root_mean_squared_error
Datasets: 4
Resultsets: 5
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 11:10 AM
Dataset (4) lazy.IB | (1) rule (2) func (3) func (5) tree
---------------------------------------------------------------------------
housing (100) 4.41 | 9.11 v 6.22 v 4.95 4.64
housing-weka.filters.unsu(100) 4.41 | 9.11 v 6.22 v 4.94 4.63
housing-weka.filters.unsu(100) 4.41 | 9.11 v 6.22 v 4.95 4.64
'housing-weka.filters.sup(100) 4.27 | 9.11 v 6.22 v 5.19 v 4.64
---------------------------------------------------------------------------
(v/ /*) | (4/0/0) (4/0/0) (1/3/0) (0/4/0)
Key:
(1) rules.ZeroR '' 48055541465867954
(2) functions.SimpleLinearRegression '' 1679336022895414137
(3) functions.SMOreg '-C 1.0 -N 0 -I \"functions.supportVector.RegSMOImproved -T 0.001 -V -P 1.0E-12 -L 0.001 -W 1\" -K \"functions.supportVector.PolyKernel -E 1.0 -C 250007\"' -7149606251113102827
(4) lazy.IBk '-K 3 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(5) trees.REPTree '-M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0' -9216785998198681299
我们可以看到，除了与 REPTree 算法和 SMOreg 进行比较之外，IBk 和其他算法之间确实有显著的差异。IBk 和 SMOreg 算法都是可以进一步调整的非线性回归算法，我们可以在下一节中看到。
5.调整算法表现
在前一节中，有两种算法在这个问题上表现良好，是进一步调优的好选择:k 近邻(IBk)和支持向量回归(SMOreg)。
在本节中，我们将设计实验来调整这两种算法，并看看我们是否可以进一步降低均方根误差。
我们将在这些实验中使用基线 housing-numeric.arff 数据集，因为使用数据集的这种变化和其他视图之间似乎没有很大的表现差异。
调谐 k-最近邻
在本节中，我们将调整 IBk 算法。具体来说，我们将研究使用不同的 k 参数值。
1.打开 Weka 实验环境界面。
2.点击“新建”开始新的实验。
3.在“实验类型”窗格中，将问题类型从“分类”更改为“回归”。
4.在“数据集”窗格中，添加 housing-numeric.arff 数据集。
5.在“算法”窗格中，懒惰。IBk 算法，并将“K”参数的值设置为 1(默认值)。重复此过程，并为 IBk 算法添加以下附加配置:
- 懒惰。K=3 的 IBk
- 懒惰。K=5 的 IBk
- 懒惰。K=7 的 IBk
- 懒惰。K=9 的 IBk
Weka 波士顿房价数据集调整 k 近邻算法
6.点击“运行”打开“运行”标签，点击“开始”按钮运行实验。实验应该在几秒钟内完成。
7.点击“分析”打开“分析”标签。单击“实验”按钮加载实验结果。
8.将“比较字段”更改为“均方根误差”。
9.单击“执行测试”按钮执行成对测试。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 0 -stddev-width 0 -sig-width 0 -count-width 5 -print-col-names -print-row-names -enum-col-names"
Analysing: Root_mean_squared_error
Datasets: 1
Resultsets: 5
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 11:27 AM
Dataset (1) lazy.IB | (2) lazy (3) lazy (4) lazy (5) lazy
---------------------------------------------------------------------------
housing (100) 4.61 | 4.41 4.71 5.00 5.16
---------------------------------------------------------------------------
(v/ /*) | (0/1/0) (0/1/0) (0/1/0) (0/1/0)
Key:
(1) lazy.IBk '-K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(2) lazy.IBk '-K 3 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(3) lazy.IBk '-K 5 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(4) lazy.IBk '-K 7 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(5) lazy.IBk '-K 9 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
我们看到 K=3 实现了最低的误差。
10.点击“测试基地”的“选择”按钮，选择懒惰。以 K=3 为新测试基的 IBk 算法。
11.单击“执行测试”按钮重新运行分析。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 2 -stddev-width 2 -sig-width 1 -count-width 5 -print-col-names -print-row-names -enum-col-names"
Analysing: Root_mean_squared_error
Datasets: 1
Resultsets: 5
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 11:28 AM
Dataset (2) lazy.IB | (1) lazy (3) lazy (4) lazy (5) lazy
---------------------------------------------------------------------------
housing (100) 4.41 | 4.61 4.71 v 5.00 v 5.16 v
---------------------------------------------------------------------------
(v/ /*) | (0/1/0) (1/0/0) (1/0/0) (1/0/0)
Key:
(1) lazy.IBk '-K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(2) lazy.IBk '-K 3 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(3) lazy.IBk '-K 5 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(4) lazy.IBk '-K 7 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
(5) lazy.IBk '-K 9 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\"' -3080186098777067172
我们可以看到，K=3 与除 K=1 之外的所有其他配置都有显著不同，并且更好。我们了解到，我们不能通过调整 IBk 的 k 来显著提升表现。
进一步的调整可能会考虑使用不同的距离度量，或者使用数据集的不同视图(例如具有选定要素的视图)来调整 IBk 参数。
调整支持向量机
在本节中，我们将调整 SMOreg 算法。具体来说，我们将研究多项式核的“指数”参数使用不同的值。
1.打开 Weka 实验环境界面。
2.点击“新建”开始新的实验。
3.在“实验类型”窗格中，将问题类型从“分类”更改为“回归”。
4.在“数据集”窗格中，添加 housing-numeric.arff 数据集。
5.在“算法”窗格中，函数。SMOreg 算法，并将多项式内核的“指数”参数值设置为 1(默认值)。重复此过程，并为 SMOreg 算法添加以下附加配置:
- 功能。SMOreg，核=多项式，指数=2
- 功能。SMOreg，核=多项式，指数=3
Weka 波士顿房价数据集调整支持向量回归算法
6.点击“运行”打开“运行”标签，点击“开始”按钮运行实验。实验应该在大约 10 分钟内完成，这取决于您系统的速度。
7.点击“分析”打开“分析”标签。单击“实验”按钮加载实验结果。
8.将“比较字段”更改为“均方根误差”。
9.单击“执行测试”按钮执行成对测试。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 2 -stddev-width 2 -sig-width 1 -count-width 5 -print-col-names -print-row-names -enum-col-names"
Analysing: Root_mean_squared_error
Datasets: 1
Resultsets: 3
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 11:47 AM
Dataset (1) functio | (2) func (3) func
---------------------------------------------------------
housing (100) 4.95 | 3.57 * 3.41 *
---------------------------------------------------------
(v/ /*) | (0/0/1) (0/0/1)
Key:
(1) functions.SMOreg '-C 1.0 -N 0 -I \"functions.supportVector.RegSMOImproved -T 0.001 -V -P 1.0E-12 -L 0.001 -W 1\" -K \"functions.supportVector.PolyKernel -E 1.0 -C 250007\"' -7149606251113102827
(2) functions.SMOreg '-C 1.0 -N 0 -I \"functions.supportVector.RegSMOImproved -T 0.001 -V -P 1.0E-12 -L 0.001 -W 1\" -K \"functions.supportVector.PolyKernel -E 2.0 -C 250007\"' -7149606251113102827
(3) functions.SMOreg '-C 1.0 -N 0 -I \"functions.supportVector.RegSMOImproved -T 0.001 -V -P 1.0E-12 -L 0.001 -W 1\" -K \"functions.supportVector.PolyKernel -E 3.0 -C 250007\"' -7149606251113102827
看起来指数=3 的内核达到了最好的结果。将其设置为“测试基准”，然后重新运行分析。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 2 -stddev-width 2 -sig-width 1 -count-width 5 -print-col-names -print-row-names -enum-col-names"
Analysing: Root_mean_squared_error
Datasets: 1
Resultsets: 3
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 11:48 AM
Dataset (3) functio | (1) func (2) func
---------------------------------------------------------
housing (100) 3.41 | 4.95 v 3.57
---------------------------------------------------------
(v/ /*) | (1/0/0) (0/1/0)
Key:
(1) functions.SMOreg '-C 1.0 -N 0 -I \"functions.supportVector.RegSMOImproved -T 0.001 -V -P 1.0E-12 -L 0.001 -W 1\" -K \"functions.supportVector.PolyKernel -E 1.0 -C 250007\"' -7149606251113102827
(2) functions.SMOreg '-C 1.0 -N 0 -I \"functions.supportVector.RegSMOImproved -T 0.001 -V -P 1.0E-12 -L 0.001 -W 1\" -K \"functions.supportVector.PolyKernel -E 2.0 -C 250007\"' -7149606251113102827
(3) functions.SMOreg '-C 1.0 -N 0 -I \"functions.supportVector.RegSMOImproved -T 0.001 -V -P 1.0E-12 -L 0.001 -W 1\" -K \"functions.supportVector.PolyKernel -E 3.0 -C 250007\"' -7149606251113102827
指数=3 的结果在统计学上明显好于指数=1，但指数=2 的结果则不然。尽管复杂度指数较低的指数=2 可能更快且不太脆弱，但是可以选择其中的任何一个。
6.评估集成算法
在评估计法的部分，我们注意到 REPtree 也取得了很好的结果，与 IBk 或 SMOreg 没有统计学上的显著差异。在本节中，我们考虑使用装袋的回归树的集合变种。
与前面关于算法优化的部分一样，我们将使用房屋数据集的数字副本。
1.打开 Weka 实验环境界面。
2.点击“新建”开始新的实验。
3.在“实验类型”窗格中，将问题类型从“分类”更改为“回归”。
4.在“数据集”窗格中，添加 housing-numeric.arff 数据集。
5.在“算法”窗格中，添加以下算法:
- 树木。REPTree
- 树木。随机森林
- 梅塔。制袋材料
Weka 波士顿房价数据集集成实验设计
6.点击“运行”打开“运行”标签，点击“开始”按钮运行实验。实验应该在几秒钟内完成。
7.点击“分析”打开“分析”标签。单击“实验”按钮加载实验结果。
8.将“比较字段”更改为“均方根误差”。
9.单击“执行测试”按钮执行成对测试。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 2 -stddev-width 2 -sig-width 1 -count-width 5 -print-col-names -print-row-names -enum-col-names"
Analysing: Root_mean_squared_error
Datasets: 1
Resultsets: 3
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 11:50 AM
Dataset (1) trees.R | (2) tree (3) meta
---------------------------------------------------------
housing (100) 4.64 | 3.14 * 3.78 *
---------------------------------------------------------
(v/ /*) | (0/0/1) (0/0/1)
Key:
(1) trees.REPTree '-M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0' -9216785998198681299
(2) trees.RandomForest '-P 100 -I 100 -num-slots 1 -K 0 -M 1.0 -V 0.001 -S 1' 1116839470751428698
(3) meta.Bagging '-P 100 -S 1 -num-slots 1 -I 10 -W trees.REPTree -- -M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0' -115879962237199703
10.结果表明，随机森林可能具有最好的表现。选择树。随机森林作为“测试基地”，重新运行分析。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 2 -stddev-width 2 -sig-width 1 -count-width 5 -print-col-names -print-row-names -enum-col-names"
Analysing: Root_mean_squared_error
Datasets: 1
Resultsets: 3
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 11:51 AM
Dataset (2) trees.R | (1) tree (3) meta
---------------------------------------------------------
housing (100) 3.14 | 4.64 v 3.78 v
---------------------------------------------------------
(v/ /*) | (1/0/0) (1/0/0)
Key:
(1) trees.REPTree '-M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0' -9216785998198681299
(2) trees.RandomForest '-P 100 -I 100 -num-slots 1 -K 0 -M 1.0 -V 0.001 -S 1' 1116839470751428698
(3) meta.Bagging '-P 100 -S 1 -num-slots 1 -I 10 -W trees.REPTree -- -M 2 -V 0.001 -N 3 -S 1 -L -1 -I 0.0' -115879962237199703
这非常令人鼓舞，RandomForest 的结果是我们迄今为止在这个问题上看到的最好的结果，与 Bagging 和 REPtree 相比，这种差异在统计上是显著的。
总结一下，让我们选择 RandomForest 作为这个问题的首选模型。
我们可以执行模型选择，并评估与 K=1 的 IBk 和指数=3 的 SMOreg 相比，RandomForest 的表现差异是否具有统计学意义。这是留给读者的练习。
11.选中“显示标准”。偏差”来表示结果的标准偏差…
12.单击“显示的列”的“选择”按钮，然后选择“树”。随机森林”，点击“选择”接受选择。这将显示随机森林算法的结果。
13.单击“执行测试”重新运行分析。
我们现在有了一个可以用来描述我们模型的最终结果。
Tester: weka.experiment.PairedCorrectedTTester -G 4,5,6 -D 1 -R 2 -S 0.05 -V -result-matrix "weka.experiment.ResultMatrixPlainText -mean-prec 2 -stddev-prec 2 -col-name-width 0 -row-name-width 25 -mean-width 2 -stddev-width 2 -sig-width 1 -count-width 5 -show-stddev -print-col-names -print-row-names -enum-col-names"
Analysing: Root_mean_squared_error
Datasets: 1
Resultsets: 3
Confidence: 0.05 (two tailed)
Sorted by: -
Date: 10/06/16 11:55 AM
Dataset (2) trees.RandomFor
---------------------------------------------
housing (100) 3.14(0.65) |
---------------------------------------------
(v/ /*) |
Key:
(2) trees.RandomForest '-P 100 -I 100 -num-slots 1 -K 0 -M 1.0 -V 0.001 -S 1' 1116839470751428698
我们可以看到，模型在看不见的数据上的估计误差为 3.14(千美元)，标准偏差为 0.64。
7.最终确定模型并展示结果
我们可以根据所有训练数据创建模型的最终版本，并将其保存到文件中。
- 打开 Weka Explorer 并加载外壳-numeric.arff 数据集。
- 点击分类。
- 选择树。RandomForest 算法。
- 将“测试选项”从“交叉验证”更改为“使用训练集”。
- 单击“开始”按钮创建最终模型。
- 右键单击“结果列表”中的结果项，然后选择“保存模型”。选择合适的位置并键入合适的名称，例如您的模型的“housing-randomforest”。
该模型可以在以后加载，并用于对新数据进行预测。
我们可以使用上一节中收集的模型准确率的平均值和标准偏差来帮助量化模型在未知数据上的估计准确率的预期可变性。
我们通常可以预计，该模型在看不见的数据上的表现将为 3.14±2 * 0.64 或 1.28。我们可以重申这一点，因为以千美元计算，该模型的误差在 1.86 和 4.42 之间。
摘要
在这篇文章中，你发现了如何使用 Weka 机器学习工作台解决回归机器学习问题。
具体来说，你学会了。
- 如何在 Weka 中加载、分析和准备数据集视图。
- 如何使用 Weka 实验员评估一套回归机器学习算法。
- 如何调整表现良好的模型，并研究相关的集成方法，以提高表现。
关于在 Weka 中解决回归机器学习问题，或者这个帖子，你有什么问题吗？在下面的评论中提出你的问题，我会尽力回答。
如何保存你的机器学习模型并在 Weka 中做出预测
原文：https://machinelearningmastery.com/save-machine-learning-model-make-predictions-weka/
最后更新于 2020 年 12 月 10 日
找到表现良好的机器学习模型并对其进行调整后，您必须最终确定模型，以便能够对新数据进行预测。
在这篇文章中，你将发现如何最终确定你的机器学习模型，将其保存到文件中，并在以后加载，以便对新数据进行预测。
看完这篇文章你会知道:
- 如何在 Weka 中训练你的机器学习模型的最终版本。
- 如何将最终模型保存到文件中。
- 如何在以后加载最终模型，并使用它对新数据进行预测。
用我的新书用 Weka 启动你的项目，包括的分步教程和清晰的截图所有示例。
我们开始吧。
如何保存您的机器学习模型并在 Weka 中进行预测尼克·肯里克摄，版权所有。
教程概述
本教程分为 4 个部分:
- 定型模型在这里您将发现如何训练模型的定型版本。
- 保存模型在这里你会发现如何将模型保存到文件中。
- 加载模型您将发现如何从文件中加载模型。
- 进行预测在这里你会发现如何对新数据进行预测。
本教程提供了一个模板，您可以使用它来完成自己的数据问题机器学习算法。
我们将使用皮马印第安人糖尿病发病数据集。每个实例代表一名患者的医疗细节，任务是预测该患者是否会在未来五年内出现糖尿病。有 8 个数值输入变量，并且都有不同的标度。
最高的结果大约是 77%的准确率。
我们将在这个数据集上最终确定一个逻辑回归模型，这既是因为它是一个简单的算法，容易理解，也是因为它在这个问题上做得很好。
1.最终确定机器学习模型
也许机器学习项目中最被忽视的任务是如何最终确定你的模型。
一旦你完成了准备数据、比较算法并根据你的问题调整它们的所有工作，你实际上需要创建你打算用来进行新预测的最终模型。
最终确定一个模型包括在您拥有的整个训练数据集上训练模型。
1.打开 Weka 图形用户界面选择器。
2.点击“浏览器”按钮，打开 Weka 浏览器界面。
3.从数据/diabetes.arff 文件中加载皮马印第安人糖尿病发病数据集。
Weka 负荷皮马印度人糖尿病发病数据集
4.单击“分类”选项卡打开分类器。
5.点击“选择”按钮，选择“功能”组下的“物流”。
6.选择“测试选项”下的“使用训练集”。
7.单击“开始”按钮。
Weka 列车逻辑回归模型
这将在整个加载的数据集上训练所选的逻辑回归算法。它还将在整个数据集上评估模型，但我们对这种评估不感兴趣。
假设您已经使用交叉验证评估了模型在未知数据上的表现，作为选择您希望最终确定的算法的一部分。当你需要告知他人你的模型的技能时，你可以报告你之前准备的评估。
既然我们已经最终确定了模型，我们需要将其保存到文件中。
2.将最终模型保存到文件
继续上一节，我们需要将最终模型保存到磁盘上的一个文件中。
这是为了我们可以在以后加载它，甚至在未来的不同计算机上使用它来进行预测。我们将来不需要训练数据，只需要数据的模型。
您可以轻松地将训练好的模型保存到 Weka Explorer 界面中的文件中。
1.在“分类”选项卡的“结果列表”中，右键单击模型的结果项。
2.从右键菜单中单击“保存模型”。
Weka 将模型保存到文件
3.选择一个位置并输入文件名，如“物流”，点击“保存”按钮。
您的模型现在保存到文件“logistic.model”中。
它是二进制格式(不是文本)，可以被 Weka 平台再次读取。因此，记下您用来创建模型文件的 Weka 版本是一个好主意，以防将来您需要相同版本的 Weka 来加载模型并进行预测。一般来说，这不会是一个问题，但这是一个很好的安全预防措施。
你现在可以关闭 Weka 浏览器了。下一步是发现如何加载保存的模型。
3.加载最终模型
您可以从文件中加载保存的 Weka 模型。
Weka 浏览器界面使这变得容易。
1.打开 Weka 图形用户界面选择器。
2.点击“浏览器”按钮，打开 Weka 浏览器界面。
3.加载任何旧数据集，都没有关系。我们不会使用它，我们只需要加载一个数据集来访问“分类”选项卡。如果不确定，再次加载数据/diabetes.arff 文件。
4.单击“分类”选项卡打开分类器。
5.右键单击“结果列表”，然后单击“加载模型”，选择上一节“逻辑模型”中保存的模型。
从文件加载模型
模型现在将被加载到资源管理器中。
我们现在可以使用加载的模型来预测新数据。
从准备使用的文件加载的 Weka 模型
4.对新数据进行预测
我们现在可以根据新数据做出预测。
首先，让我们创建一些假装的新数据。将文件 data/diabetes.arff 复制一份，保存为data/diabetes-new-data . ARFF。
在文本编辑器中打开文件。
用第 95 行的@data 找到文件中实际数据的开头。
我们只想保留 5 条记录。向下移动 5 行，然后删除文件的所有剩余行。
我们想要预测的类值(输出变量)在每一行的末尾。删除 5 个输出变量中的每一个，并用问号符号(？).
用于进行新预测的 Weka 数据集
我们现在有“看不见的”数据，没有已知的输出，我们想对其进行预测。
从教程的前一部分继续，我们已经加载了模型。
1.在“分类”选项卡上，选择“测试选项”窗格中的“提供的测试集”选项。
Weka 选择要进行新预测的新数据集
2.单击“设置”按钮，单击选项窗口上的“打开文件”按钮，选择我们刚刚创建的名为“糖尿病-新-数据. arff”的模拟新数据集。单击窗口上的“关闭”。
3.单击“更多选项…”按钮，调出评估分类器的选项。
4.取消选中我们不感兴趣的信息，特别是:
- “输出模型”
- “输出每类统计信息”
- “输出混淆矩阵”
- “存储可视化预测”
用于预测的 Weka 定制测试选项
5.对于“输出预测”选项，单击“选择”按钮并选择“明文”。
纯文本格式的 Weka 输出预测
6.单击“确定”按钮确认分类器评估选项。
7.在“结果列表”窗格中右键单击已加载模型的列表项。
8.选择“在当前测试集上重新评估模型”。
weka 根据测试数据重新评估加载模型并做出预测
然后在“分类器输出”窗格中列出每个测试实例的预测。具体来说，结果的中间一列有“测试阳性”和“测试阴性”这样的预测。
您可以为预测选择另一种输出格式，例如 CSV，稍后可以将其加载到 Excel 等电子表格中。例如，下面是 CSV 格式的相同预测的示例。
Weka 用加载模型对新数据的预测
更多信息
Weka Wiki 提供了更多关于保存和加载模型以及做出您可能会发现有用的预测的信息:
摘要
在这篇文章中，你发现了如何最终确定你的模型，并对新的未知数据做出预测。你可以看到如何使用这个过程来自己对新数据进行预测。
具体来说，您了解到:
- 如何训练机器学习模型的最终实例？
- 如何将最终模型保存到文件中以备后用？
- 如何从文件中加载模型，并使用它对新数据进行预测。
你对如何在 Weka 最终确定你的模型或这篇文章有什么问题吗？在下面的评论中提出你的问题，我会尽力回答。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
