H2O 自动机器学习实践指南（一）

原文：annas-archive.org/md5/598d72a11813e0f14a8bd7ffc3aed879

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

随着互联网上产生的数据量巨大以及机器学习（ML）预测给企业带来的好处，ML 的实施已经成为一个低垂的果实，每个人都为之努力。然而，其背后的复杂数学可能会让很多用户感到沮丧。这就是 H2O 发挥作用的地方——它自动化了各种重复步骤，这种封装帮助开发者专注于结果而不是处理复杂性。

你将从理解 H2O 的 AutoML 如何通过提供一个简单、易于使用的界面来简化 ML 的实施开始。接下来，你将看到 AutoML 如何自动化训练多个模型、优化它们的超参数以及解释它们的性能。随着你的进步，你将了解到如何利用普通 Java 对象（POJO）和模型对象优化（MOJO）将你的模型部署到生产环境中。在这本书中，你将通过使用 H2O 的实际操作方法来学习，这将使你能够迅速设置你的 ML 系统。

在阅读完这本 H2O 书籍之后，你将能够使用 H2O AutoML 训练和使用你的 ML 模型，从实验到生产，无需理解复杂的统计学或数据科学。

这本书面向谁

这本书是为那些想要快速将 ML 融入他们的产品而无需担心训练 ML 模型内部复杂性的工程师和数据科学家而编写的。

如果你是一个想要将机器学习（ML）融入你的软件系统但不知道从何开始或在该领域没有太多专业知识的人，那么你会发现这本书很有用。

这本书涵盖的内容

第一章，理解 H2O AutoML 基础知识，介绍了 H2O.ai 的 AutoML 技术，并实现了一个基本的技术设置以观察其实际应用。

第二章，使用 H2O Flow（H2O 的 Web UI），探讨了 H2O 的 Web UI，称为 H2O Flow，并展示了我们如何使用 Web UI 设置我们的 H2O AutoML 系统，而无需编写任何代码。

第三章，理解数据处理，探讨了我们可以使用 H2O 内置的数据框操作执行的一些常见数据处理功能。

第四章，理解 H2O AutoML 训练和架构，深入探讨了 H2O 技术的高级架构，并教我们 H2O AutoML 如何训练所有模型并优化它们的超参数。

第五章，理解 AutoML 算法，探讨了 H2O AutoML 用于训练各种模型的多种机器学习算法。

第六章，理解 H2O AutoML 排行榜和其他性能指标，探讨了在 AutoML 排行榜中使用的不同性能指标，以及一些对用户来说很重要的附加指标。

第七章，使用模型可解释性，探讨了 H2O 可解释性界面，并帮助我们理解我们作为输出获得的各种可解释性功能。

第八章，探索 H2O AutoML 的可选参数，查看我们在配置 AutoML 训练时可用的一些可选参数，并展示如何使用它们。

第九章，探索 H2O AutoML 中的其他功能，探讨了 H2O AutoML 的两个独特功能。第一个是 H2O AutoML 与 scikit-learn 库的兼容性，第二个是 H2O AutoML 内置的日志系统，用于调试 AutoML 训练问题。

第十章，使用普通 Java 对象（POJOs），涵盖了模型 POJOs 以及我们如何提取和使用它们在生产环境中进行预测。

第十一章，使用模型对象，优化（MOJO），涵盖了模型 MOJOs，它们与模型 POJOs 的不同之处，如何查看它们，以及我们如何提取和使用它们在生产环境中进行预测。

第十二章，使用 H2O AutoML 和 Apache Spark，详细探讨了如何使用 H2O Sparkling Water 将 H2O AutoML 与 Apache Spark 结合使用。

第十三章，使用 H2O AutoML 与其他技术结合，探讨了如何将 H2O 模型与其他在机器学习领域常用的技术（如 Spring Boot Web 应用程序和 Apache Storm）协同使用。

为了充分利用本书

基本的统计学和编程知识有益。对机器学习和 Python 的一些了解将有所帮助。您需要在计算机上安装 Python，最好是 3.7 或更高版本，或者安装 R，版本为 4.0 或更高。所有代码示例都已使用 Windows 10 操作系统和 Ubuntu 22.04.1 LTS 上的 Python 3.10 和 R 4.1.2 进行测试。然而，它们也应该适用于未来的版本发布。

本书涵盖的软件/硬件	操作系统要求
Python 3.10	Windows、macOS 或 Linux
R 4.1.2
H2O 3.36.1.4
Java 11
Spark 3.2
Scala 2.13
Maven 3.8.6

如果您正在使用这本书的数字版，我们建议您亲自输入代码或访问 本书的 GitHub 代码库（下一节中提供了链接）。这样做将帮助您避免与代码复制和粘贴相关的任何潜在错误。

下载示例代码文件

您可以从 GitHub 下载本书的示例代码文件：github.com/PacktPublishing/Practical-Automated-Machine-Learning-on-H2O。如果代码有更新，它将在 GitHub 仓库中更新。

我们还有其他来自我们丰富图书和视频目录的代码包，可在github.com/PacktPublishing/找到。查看它们吧！

下载彩色图像

我们还提供了一份包含本书中使用的截图和图表彩色图像的 PDF 文件。您可以从这里下载：packt.link/IighZ。

使用的约定

本书使用了多种文本约定。

文本中的代码：表示文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 昵称。以下是一个示例：“使用 POJO 模型唯一的依赖是h2o-genmodel.jar文件。”

代码块设置如下：

import h2o
h2o.init()

当我们希望您注意代码块中的特定部分时，相关的行或项目将以粗体显示：

data_frame = h2o.import_file("Dataset/iris.data")

任何命令行输入或输出都按照以下方式编写：

mkdir H2O_POJO
cd H2O_POJO 

粗体：表示新术语、重要单词或您在屏幕上看到的单词。例如，菜单或对话框中的单词以粗体显示。以下是一个示例：“您可以简单地点击下载 POJO按钮来下载模型作为 POJO。”

小贴士或重要提示

看起来是这样的。

联系我们

我们始终欢迎读者的反馈。

一般反馈：如果您对本书的任何方面有疑问，请通过customercare@packtpub.com给我们发邮件，并在邮件主题中提及书名。

勘误：尽管我们已经尽最大努力确保内容的准确性，但错误仍然可能发生。如果您在这本书中发现了错误，我们将不胜感激，如果您能向我们报告，我们将非常感谢。请访问www.packtpub.com/support/errata并填写表格。

盗版：如果您在互联网上以任何形式遇到我们作品的非法副本，我们将不胜感激，如果您能提供位置地址或网站名称，我们将非常感谢。请通过copyright@packt.com与我们联系，并提供材料的链接。

如果您有兴趣成为作者：如果您在某个领域有专业知识，并且您有兴趣撰写或为本书做出贡献，请访问authors.packtpub.com。

分享您的想法

一旦您阅读了《使用 H2O.ai 的实用自动化机器学习》，我们很乐意听到您的想法！请点击此处直接进入此书的亚马逊评论页面并分享您的反馈。

您的审阅对我们和科技社区都至关重要，并将帮助我们确保我们提供高质量的内容。

第一部分 H2O AutoML 基础

本部分的目标是帮助您实现一个简单、基础的演示，展示如何安装、设置和使用 H2O AutoML，从而进一步探索和实验这项技术。

本节包含以下章节：

• 第一章, 理解 H2O AutoML 基础

• 第二章, 使用 H2O 流 (H2O 的 Web UI)

第一章：理解 H2O AutoML 基础

机器学习（ML）是使用计算机系统构建分析或统计模型的过程，这些系统通过学习历史数据并从中识别模式。然后，这些系统使用这些模式并尝试做出预测性决策，这些决策可以为企业和研究提供价值。然而，实现一个能够提供任何具体价值的 ML 系统所需的复杂数学知识已经阻止了很多人尝试它，留下了大量他们本可以从中受益的未发现潜力。

自动化机器学习（AutoML）是最新 ML 技术之一，它加速了所有规模的组织对 ML 的采用。它是自动所有这些涉及 ML 生命周期复杂任务的过程。AutoML 将所有这些复杂性隐藏起来并在幕后自动化它们。这使得任何人都可以轻松实现 ML 而无需任何麻烦，并更多地关注结果。

本章，我们将学习 H2O.ai（[www.h2o.ai/](https://www.h2o.ai/））提供的一种 AutoML 技术，它简单地命名为 H2O AutoML。我们将提供 AutoML 的一般历史和它解决的问题的简要介绍，以及关于 H2O.ai 及其 H2O AutoML 技术的一些信息。然后，我们将使用 H2O 的 AutoML 技术编写一个简单的 ML 实现并构建我们的第一个 ML 模型。

到本章结束时，你将了解 AutoML 究竟是什么，H2O.ai 公司及其技术 H2O AutoML，以及使用 H2O AutoML 需要的最小要求。你还将了解如何使用 H2O AutoML 训练你的第一个 ML 模型，而无需理解任何复杂的数学火箭科学。

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

• 理解 AutoML 和 H2O AutoML

• 使用 H2O AutoML 的最小系统要求

• 安装 Java

• 使用 Python 的 H2O 的基本实现

• 使用 R 的 H2O 的基本实现

• 使用 H2O AutoML 训练你的第一个 ML 模型

技术要求

对于本章，你需要以下内容：

• 一个不错的网络浏览器（Chrome、Firefox 或 Edge），你首选浏览器的最新版本。

• 你选择的 集成开发环境（IDE）

• Project Jupyter 的 Jupyter Notebook (https://jupyter.org/)（可选）

本章的所有代码示例都可以在 GitHub 上找到，链接为 github.com/PacktPublishing/Practical-Automated-Machine-Learning-on-H2O/tree/main/Chapter%201。

理解 AutoML 和 H2O AutoML

在我们开始使用 H2O AutoML 的旅程之前，了解 AutoML 究竟是什么以及它在整个机器学习（ML）流程中扮演什么角色是非常重要的。在本节中，我们将尝试理解 ML 流程中涉及的各个步骤以及 AutoML 如何融入其中。然后，我们将探讨是什么使得 H2O 的 AutoML 在众多 AutoML 技术中如此独特。

让我们先了解一下 AutoML 的一般概念。

AutoML

AutoML 是一个自动化过程，用于在开发用于预测的有效 ML 系统时执行的各种步骤。一个典型的 ML 流程包括以下步骤：

1. 数据收集：这是 ML 流程中的第一步。数据从各种来源收集。这些来源可以生成不同类型的数据，如分类数据、数值数据、文本数据、时间序列数据，甚至视觉和听觉数据。所有这些类型的数据根据需求聚合在一起，并合并成一个共同的结构。这可能是一个逗号分隔值文件、一个 parquet 文件，甚至是一个数据库的表格。

2. 数据探索：一旦收集到数据，就会使用基本的分析技术对其进行探索，以确定其包含的内容、数据的完整性和正确性，以及数据是否显示出可以构建模型的潜在模式。

3. 数据准备：缺失值、重复数据和噪声数据都可能影响模型的质量，因为它们引入了错误的学习。因此，收集和探索的原始数据需要通过特定的数据处理方法进行预处理，以消除所有异常。

4. 数据转换：许多 ML 模型可以处理不同类型的数据。一些可以处理分类数据，而另一些只能处理数值数据。这就是为什么你可能需要将某些类型的数据从一种形式转换为另一种形式。这允许在模型训练期间正确地提供数据集。

5. 模型选择：一旦数据集准备就绪，就需要选择一个 ML 模型进行训练。模型的选择基于数据集包含的数据类型、需要从数据集中提取的信息以及哪种模型适合数据。

6. 模型训练：这是模型被训练的地方。ML 系统将从处理后的数据集中学习并创建一个模型。这种训练可以受到多个因素的影响，例如数据属性加权、学习率和其他超参数。

7. 超参数调整：除了模型训练之外，还需要考虑模型的架构。模型的架构取决于所使用的算法类型，例如随机森林中的树的数量或神经网络中的神经元数量。我们并不立即知道哪种架构对给定的模型是最优的，因此需要进行实验。定义模型架构的参数称为超参数；找到最佳的超参数值组合被称为超参数调整。

8. 预测：机器学习管道的最终步骤是预测。基于模型在训练期间学习到的数据集模式，模型现在可以对未见数据做出一般化的预测。

对于非专业人士来说，所有这些步骤及其复杂性可能会令人感到压倒。机器学习管道过程中的每个步骤都是经过多年研究开发的，并且其中包含着广泛的主题。AutoML 是自动化这些步骤的大多数过程的过程，从数据探索到超参数调整，并提供最佳模型进行预测。这有助于公司专注于用结果解决现实世界问题，而不是机器学习过程和工作流程。

现在您已经了解了机器学习管道中的不同步骤以及这些步骤是如何被 AutoML 自动化的，让我们来看看为什么 H2O 的 AutoML 技术是行业领先技术之一。

H2O AutoML

H2O AutoML 是由 H2O.ai 开发的一种 AutoML 软件技术，通过提供用户友好的界面，帮助非专业人士进行机器学习实验，从而简化了机器学习系统的开发过程。它是一个内存中、分布式、快速且可扩展的机器学习和分析平台，适用于大数据，并且可以满足企业需求。

它是用 Java 编写的，并使用键值存储来访问数据、模型和其他涉及的机器学习对象。它运行在集群系统上，并使用多线程 MapReduce 框架来并行化数据操作。它还很容易与之通信，因为它使用简单的 REST API。最后，它有一个提供数据细节和模型详细信息的图形视图的网页界面。

H2O AutoML 不仅自动化了机器学习生命周期中涉及的大多数复杂步骤，还为即使是专家数据科学家实施专门的模型训练过程提供了很多灵活性。H2O AutoML 提供了一个简单的包装函数，封装了几个原本需要复杂编排的模型训练任务。它还拥有广泛的可解释性功能，可以描述模型训练生命周期的各种细节。这为用户提供易于导出的模型细节，用户可以使用这些细节来解释已训练模型的性能和合理性。

H2O AutoML 最好的部分是它是完全开源的。您可以在github.com/h2oai找到 H2O 的源代码。它由一个在开源和闭源公司中服务的开发者社区积极维护。在撰写本文时，它处于第三个主要版本，这表明它是一个非常成熟的技术，并且功能丰富——也就是说，它支持世界上几家主要公司。它还支持包括 R、Scala、Python 和 Java 在内的多种编程语言，这些语言可以在多个操作系统上运行，并为涉及机器学习生命周期的各种数据源提供支持，例如 Hadoop 分布式文件系统、Hive、Amazon S3，甚至Java 数据库连接（JDBC）。

现在您已经了解了 AutoML 的基本知识以及 H2O AutoML 的强大功能，让我们看看系统运行 H2O AutoML 而不出现性能问题的最低要求。

使用 H2O AutoML 的最小系统要求

H2O 安装非常简单，但要确保它运行顺畅和高效，需要满足某些最低标准要求。以下是一些 H2O 在硬件能力方面所需的最低要求，以及其他软件支持：

• H2O 所需的最小硬件如下：

  • 内存：H2O 运行在内存架构上，因此它受限于使用它的系统的物理内存。因此，为了能够处理大量数据，系统拥有的内存越多越好。

  • 中央处理器（CPU）：默认情况下，H2O 将使用系统可用的最大 CPU 数量。然而，至少需要 4 个 CPU。

  • 图形处理单元（GPU）：如果 GPU 是 NVIDIA GPU（GPU Cloud，DGX Station，DGX-1 或 DGX-2）或 CUDA 8 GPU，则 AutoML 中的 XGBoost 模型才支持 GPU。

• 支持 H2O 的操作系统如下：

  • Ubuntu 12.04

  • OS X 10.9 或更高版本

  • Windows 7 或更高版本

  • CentOS 6 或更高版本

• 支持 H2O 的编程语言如下：

  • Java：Java 是 H2O 的强制要求。H2O 构建需要 64 位 JDK，运行其二进制文件需要 64 位 JRE：

    • 支持的 Java 版本：Java SE 15，14，13，12，11，10，9 和 8

  • 其他语言：以下语言仅在 H2O 在这些环境中运行时需要：

    • Python 2.7.x，3.5.x 或 3.6.x

    • Scala 2.10 或更高版本

    • R 版本 3 或更高版本

• 附加要求：以下要求仅在 H2O 在这些环境中运行时需要：

  • Hadoop：Cloudera CDH 5.4 或更高版本，Hortonworks HDP 2.2 或更高版本，MapR 4.0 或更高版本，或 IBM Open Platform 4.2

  • Conda：2.7，3.5 或 3.6

  • Spark：版本 2.1，2.2 或 2.3

一旦我们有一个满足最低要求的系统，我们需要关注 H2O 对其他软件的功能依赖。H2O 只有一个依赖项，那就是 Java。让我们看看为什么 Java 对 H2O 很重要，以及我们如何下载和安装正确的支持 Java 版本。

安装 Java

H2O 的核心代码是用 Java 编写的。它需要在你的系统中安装 Java 运行环境（JRE）来启动 H2O 服务器集群。H2O 还以多线程方式训练所有机器学习算法，这在其 MapReduce 框架之上使用了 Java Fork/Join 框架。因此，拥有与 H2O 兼容的最新 Java 版本以顺畅运行 H2O 非常推荐。

你可以从 www.oracle.com/java/technologies/downloads/ 下载并安装最新稳定的 Java 版本。

在安装 Java 时，重要的是要知道你的系统运行的是哪种位版本。如果是 64 位版本，那么请确保你正在安装适用于你操作系统的 64 位 Java 版本。如果是 32 位，那么选择 32 位版本。

现在我们已经安装了正确的 Java 版本，我们可以下载并安装 H2O。让我们看看如何使用 Python 来完成这个简单的示例。

使用 Python 的 H2O 基本实现

Python 是计算机编程中机器学习（ML）领域最受欢迎的语言之一。它在所有行业中都得到广泛应用，并且拥有大量活跃维护的 ML 库，为创建 ML 管道提供了大量支持。

我们将首先安装 Python 编程语言，然后使用 Python 安装 H2O。

安装 Python

安装 Python 非常简单。无论是 Python 2.7 还是 Python 3 及以上版本，H2O 都可以与这两种语言版本完美兼容。然而，如果你使用的是 Python 2.7 以下的版本，那么你需要升级你的版本。

最好是使用 Python 3，因为它是当前的标准，Python 2.7 已经过时。除了 Python 之外，你还需要 pip，Python 的包管理器。现在，让我们学习如何在各种操作系统上安装 Python：

• 在 Linux（Ubuntu、Mint、Debian）上：

  • 对于 Python 2.7，请在系统终端中运行以下命令：

    sudo apt-get python-pip 
    

  • 对于 Python 3，请在系统终端中运行以下命令：

    sudo apt-get python3-pip
    

• 在 macOS 上：macOS 10.8 版本预装了 Python 2.7。如果你想安装 Python 3，请访问 https://python.org，进入 下载 部分，并下载适用于 macOS 的最新 Python 3 版本。

• 在 Windows 上：与 macOS 不同，Windows 没有预安装任何 Python 语言支持。你需要从 python.org 下载 Windows 的 Python 安装程序。安装程序将取决于你的 Windows 操作系统——也就是说，如果是 64 位还是 32 位。

现在你已经知道了如何安装正确的 Python 版本，让我们使用 Python 下载并安装 H2O Python 模块。

使用 Python 安装 H2O

H2O 在 Python 包索引中有一个 Python 模块可用。要安装h2oPython 模块，您只需在您的终端中执行以下命令：

pip install h2o

就这么简单。

要测试是否已成功下载和安装，请按照以下步骤操作：

1. 打开您的 Python 终端。

2. 通过运行以下命令导入h2o模块：

   import h2o
   

3. 通过运行以下命令初始化 H2O 以启动本地h2o服务器：

   h2o.init()
   

以下截图显示了初始化h2o后应得到的结果：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_01_001.jpg

图 1.1 – 使用 Python 执行 H2O

让我们快速查看我们得到的结果。首先，它运行成功，所以任务完成。

在通过读取输出日志执行h2o.init()之后，您将看到 H2O 检查了是否在本地主机上的端口 54321 上已经有一个 H2O 服务器实例正在运行。在这种情况下，之前没有 H2O 服务器实例正在运行，所以 H2O 尝试在相同端口上启动本地服务器。如果它在该端口上找到了已经存在的本地 H2O 实例，那么它将重用该实例来执行任何进一步的 H2O 命令。

然后，它使用 Java 版本 16 启动了 H2O 实例。您可能看到不同的 Java 版本，这取决于您在系统中安装的版本。

接下来，您将看到服务器启动时使用的h2o jar文件的位置，然后是Java 虚拟机（JVM）日志的位置。

一旦服务器启动并运行，它将显示在您系统上本地托管的 H2O 服务器 URL 以及 H2O Python 库与服务器连接的状态。

最后，您将看到一些关于服务器配置的基本元数据。这些元数据可能略不同于您在执行中看到的内容，因为它在很大程度上取决于您系统的规格。例如，默认情况下，H2O 将使用系统上可用的所有核心进行处理。所以，如果您有一个 8 核心的系统，那么H2O_cluster_allowed_cores属性值将是8。或者，如果您决定只使用四个核心，那么您可以执行h2o.init(nthreads=4)来只使用四个核心，并在服务器配置输出中反映这一点。

现在您已经知道了如何使用 Python 实现 H2O，让我们学习如何在 R 编程语言中完成同样的操作。

使用 R 的基本 H2O 实现

R 编程语言在机器学习和数据科学领域非常受欢迎，因为它提供了广泛的统计和数据操作支持。数据科学家和数据挖掘者广泛使用它来开发分析软件。

我们将首先安装 R 编程语言，然后使用 R 安装 H2O。

安装 R

一支国际开发团队维护着 R 编程语言。他们为 R 编程语言设立了一个专门的网页，称为综合 R 存档网络（CRAN）：cran.r-project.org/. 根据你所使用的操作系统，安装 R 有不同的方法：

• 在 Linux（Ubuntu、Mint、Debian）上：

在系统终端中执行以下命令：

sudo apt-get install r-base

• 在 macOS 上：要安装 R，请访问 cran.r-project.org/，点击下载 R for macOS超链接，并下载适用于 macOS 的最新 R 版本。

• 在 Windows 上：与你在 macOS 上安装 R 的方法类似，你可以从 cran.r-project.org/ 下载 .exe 文件，点击下载 R for Windows超链接，并下载适用于 Windows 的最新 R 版本。

在 macOS 和 Windows 上安装 R 的另一种好方法是使用 RStudio。RStudio 简化了 R 支持软件的安装，并且也是 R 编程的非常好用的 IDE。你可以从 www.rstudio.com/ 下载 RStudio。

现在你已经知道了如何安装正确的 R 版本，让我们使用 R 编程语言下载并安装 H2O R 包。

使用 R 安装 H2O

与 Python 类似，H2O 也为 R 编程语言提供支持。

要安装 R 包，请按照以下步骤操作：

1. 首先，我们需要下载 H2O R 包的依赖项。为此，在你的 R 终端中执行以下命令：

   install.packages(c("RCurl", "jsonlite"))
   

2. 然后，为了安装实际的 h2o 包，在你的 R 终端中执行以下命令：

   install.packages("h2o")
   

完成操作。

1. 要测试是否已成功下载和安装，请打开你的 R 终端，导入 h2o 库，并执行 h2o.init() 命令。这将启动一个本地的 H2O 服务器。

结果可以在以下屏幕截图中看到：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_01_002.jpg

图 1.2 – 使用 R 执行 H2O

让我们快速查看我们得到的输出。

执行 h2o.init() 后，H2O 客户端将检查系统上是否已运行 H2O 服务器实例。H2O 服务器通常默认在端口 54321 上本地运行。如果它在该端口上找到了已存在的本地 H2O 实例，那么它将重用该实例。然而，在这个场景中，端口 54321 上没有运行任何 H2O 服务器实例，这就是为什么 H2O 尝试在相同端口上启动本地服务器的原因。

接下来，您将看到 JVM 日志的位置。一旦服务器启动并运行，H2O 客户端会尝试连接到它，并显示与服务器连接的状态。最后，您将看到一些关于服务器配置的基本元数据。这些元数据可能略不同于您在执行中看到的内容，因为它在很大程度上取决于您系统的规格。例如，默认情况下，H2O 将使用您系统上可用的所有核心进行处理。所以，如果您有一个 8 核心的系统，那么H2O_cluster_allowed_cores属性值将是8。或者，如果您决定只使用四个核心，则可以执行h2o.init(nthreads=4)命令来只使用四个核心，从而在服务器配置输出中反映出来。

现在您已经知道了如何使用 Python 和 R 实现 H2O，让我们创建我们的第一个机器学习模型，并使用 H2O AutoML 对其做出预测。

使用 H2O AutoML 训练您的第一个机器学习模型

所有机器学习管道，无论它们是否自动化，最终都遵循本章中“理解 AutoML 和 H2O AutoML”部分讨论的相同步骤。

对于这个实现，我们将使用鸢尾花数据集。这个数据集可以在archive.ics.uci.edu/ml/datasets/iris找到。

理解鸢尾花数据集

鸢尾花数据集，也称为费舍尔的鸢尾花数据集，是最受欢迎的多变量数据集之一——也就是说，这是一个在模型训练过程中每个观测值分析两个或更多变量的数据集。该数据集包括三种不同品种的鸢尾花样本 50 个。数据集中的特征包括花瓣和萼片的长度和宽度（以厘米为单位）。由于其简单性，该数据集常用于研究机器学习中的各种分类技术。分类是通过使用花瓣和萼片的长度和宽度作为特征来确定的，这些特征决定了鸢尾花的类别。

以下截图显示了数据集的一个小样本：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_01_003.jpg

图 1.3 – 鸢尾花数据集

数据集中的列代表以下内容：

• C1：萼片长度（厘米）

• C2：萼片宽度（厘米）

• C3：花瓣长度（厘米）

• C4：花瓣宽度（厘米）

• C5：类别：

  • Iris-setosa

  • Iris-versicolour

  • Iris-virginica

在这个场景中，C1、C2、C3 和 C4 代表用于确定C5（即鸢尾花类别）的特征。

现在您已经理解了我们将要处理的数据集的内容，让我们实现我们的模型训练代码。

模型训练

模型训练 是寻找给定机器学习算法的最佳偏差和权重组合的过程，以便它最小化损失函数。损失函数 是衡量预测值与实际值之间距离的一种方法。因此，最小化它表示模型正在接近做出准确的预测——换句话说，它正在学习。机器学习算法构建了数据集中各种特征与目标标签之间关系的数学表示。然后，我们使用这种数学表示来预测目标标签对于某些特征值的潜在值。预测值的准确性很大程度上取决于数据集的质量，以及模型训练期间使用的权重和偏差与特征的组合。然而，所有这些都可以由 AutoML 完全自动化，因此对我们来说不是问题。

考虑到这一点，让我们学习如何快速简单地使用 H2O 在 Python 中创建一个机器学习模型。

Python 中的模型训练和预测

H2O Python 模块使得在 Python 程序中使用 H2O 变得容易。H2O Python 模块中的内置函数易于使用，并隐藏了使用 H2O 的许多复杂性。

按照以下步骤在 Python 中使用 H2O AutoML 训练您的第一个模型：

1. 导入 H2O 模块：

   import h2o
   

2. 初始化 H2O 以启动本地 H2O 服务器：

   h2o.init()
   

h2o.init() 命令启动或重用本地端口 54321 上运行的 H2O 服务器实例。

1. 现在，您可以使用 h2o.import_file() 命令导入数据集，同时将数据集在系统中的位置传递进去。

2. 接下来，通过传递数据集下载位置来导入数据集：

   data = h2o.import_file("Dataset/iris.data")
   

3. 现在，您需要确定 DataFrame 的哪些列是特征，哪些是标签。C1、C2、C3、C4 和 C5 作为特征列表：

   features = data.columns
   

4. 根据我们的 DataFrame，表示 Iris 花类的 C5 列是我们希望在模型训练后最终预测的列。因此，我们将 C5 标记为标签，并从剩余的列名集合中删除它，我们将这些列标记为特征。设置目标标签并从特征列表中删除：

   label = "C5"
   features.remove(label)
   

5. 将 DataFrame 分割为训练和测试 DataFrame：

   train_dataframe, test_dataframe = data.split_frame([0.8])
   

data.split_frame([0.8]) 命令将 DataFrame 分割成两个——一个训练 DataFrame 和另一个用于测试的 DataFrame。训练 DataFrame 包含 80% 的数据，而测试 DataFrame 包含剩余的 20%。我们将使用训练 DataFrame 来训练模型，并在模型训练后使用测试 DataFrame 来运行预测，以测试模型的性能。

小贴士

如果你对 H2O 如何根据比例分割数据集以及如何在不同分割之间随机化数据感兴趣，请随意探索并使用 split_frame 函数进行实验。更多详细信息请参阅 https://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/_modules/h2o/frame.xhtml#H2OFrame.split_frame。

1. 初始化 H2O AutoML 对象。在这里，我们将 max_model 参数设置为 10 以限制 H2O 将训练的模型数量，将 AutoML 设置为 10，并将随机 seed 生成器设置为 1：

   aml=h2o.automl.H2OAutoML(max_models=10, seed = 1)
   

2. 现在，通过传递特征列 – 即 C1、C2、C3 和 C4 – 在 (x) 中，标签列 C5 在 (y) 中，以及使用 aml.train() 命令的 train_dataframe DataFrame 来触发 AutoML 训练。这是 H2O 开始其自动模型训练的时候。

3. 使用 H2O AutoML 对象训练模型：

   aml.train(x = features, y = label, training_frame = train_dataframe)
   

在训练过程中，H2O 将分析标签列的类型。对于数值标签，H2O 将机器学习问题视为回归问题。如果标签是分类的，那么它将问题视为分类问题。对于 Iris 花数据集，C5 列包含类值的分类值。H2O 将分析此列并正确识别它是一个分类问题，并训练分类模型。

H2O AutoML 在幕后使用不同类型的机器学习算法训练多个模型。所有已训练的模型都在测试数据集上评估，并测量其性能。H2O 还提供了有关所有模型的详细信息，用户可以使用这些信息进一步对数据进行实验或比较不同的机器学习算法，了解哪些更适合解决他们的机器学习问题。H2O 最终可能训练 20-30 个模型，这可能需要一段时间。然而，由于我们已将 max_models 参数设置为 10，因此我们限制了将被训练的模型数量，以便我们可以快速查看训练过程的输出。关于集成学习的更多内容将在 第五章，理解 AutoML 算法 中讨论。

1. 一旦训练完成，AutoML 将创建一个包含它所训练的所有模型的领航表，从表现最好的到最差的进行排名。这个排名是通过比较所有模型的错误度量来实现的。错误度量是衡量模型在预测样本测试数据集时犯错误数量的值。较低的错误度量表示模型在预测过程中犯的错误较少，这表明与错误度量较高的模型相比，它是一个更好的模型。提取 AutoML 领航表：

   model_leaderboard = aml.leaderboard
   

2. 显示 AutoML 领航表：

   model_leaderboard.head(rows=model_leaderboard.nrows)
   

领航表将如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_01_004.jpg

图 1.4 – H2O AutoML 领航表（Python）

领航表包括以下详细信息：

• model_id：这代表模型的 ID。

• mean_per_class_error：此度量用于衡量多类数据集中每个类错误的平均值。

• logloss：此度量用于衡量每个实例校正预测概率对数的负平均值。

• 均方根误差（RMSE）：此度量用于衡量预测误差的标准差。

• 均方误差（MSE）：此指标用于衡量误差平方的平均值。

根据 ML 问题的类型，排行榜会根据某些默认指标对模型进行排序，除非在 AutoML 训练期间有特别说明。对于多项式分类，排行榜会根据mean_per_class_error排序，而对于回归则是偏差。

指标是模型性能中误差的不同度量。因此，误差值越小，模型在做出准确预测方面的表现越好。我们将在第六章中探讨不同的模型性能指标，理解 H2O AutoML 排行榜和其他性能指标。

在这种情况下，GLM_1_AutoML_1_20211221_224844是 H2O AutoML 认为的最佳模型，因为它是一个多项式分类问题，并且这个模型的mean_per_class_error最低。

您可能会注意到，尽管将max_model值设置为10，但在触发 AutoML 进行训练时，我们在排行榜上看到超过 10 个模型。这是因为只有 10 个模型被训练；其余的模型是 Stacked Ensemble 模型。Stacked Ensemble模型是由其他模型学习到的内容创建的模型，并且从技术上讲并不是以正常方式训练的。我们将在第五章中了解更多关于 Stacked Ensemble 模型的信息，以及在第六章中了解更多关于排行榜的信息，理解 H2O AutoML 排行榜和其他性能指标。

恭喜！您已正式使用 H2O AutoML 训练了您的第一个 ML 模型，现在它可以用于做出预测。

做出预测非常简单：我们将使用由data.split_frame([0.8])命令创建的test_dataframe DataFrame。

在 Python 中执行以下命令：

aml.predict(test_dataframe)

就这样——一切都在模型对象的predict函数中封装。

执行预测后，您将看到以下结果：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_01_005.jpg

图 1.5 – H2O AutoML 模型预测（Python）

预测结果显示一个表格，其中每一行都是测试 DataFrame 中现有行的预测表示。predict列指示该行属于哪种 Iris 类别，而其余列是模型在读取该行的特征值后计算出的 Iris 类别的概率，如列名所示。简而言之，模型预测对于行 1，有*99.6763%*的概率是 Iris-setosa。

恭喜！您现在已使用 AutoML 训练的新模型做出了准确的预测。

现在我们已经看到了在 Python 中使用 H2O AutoML 是多么简单，让我们学习如何在 R 编程语言中做到同样的事情。

R 中的模型训练和预测

与 Python 类似，在 R 编程语言中使用 H2O AutoML 进行训练和预测也非常简单。H2O 对 R 编程语言有很多支持，因此它将许多 ML 的复杂性封装在可用的函数中。

让我们看看一个使用 R 编程语言在 Iris 花数据集上使用 H2O AutoML 进行模型训练的示例。

你会注意到在 R 中训练模型的方式与我们在 Python 中做的方式相似，唯一的区别是语法上的细微变化。

按照以下步骤操作：

1. 导入H2O库：

   library(h2o)
   

2. 初始化 H2O 以启动本地 H2O 服务器：

   h2o.init()
   

h2o.init()将启动一个运行在本地的端口 54321 上的 H2O 服务器实例，并将其连接。如果同一端口上已经存在 H2O 服务器，则将重用它。

1. 使用h2o.importFile(“Dataset/iris.data”)导入数据集，同时将数据集在系统中的位置作为参数传递。导入数据集：

   data <- h2o.importFile("Dataset/iris.data")
   

2. 现在，你需要设置数据框的哪些列是特征，哪些列是标签。将C5列设置为目标标签，其余列名作为特征列表：

   label <- "C5"
   features <- setdiff(names(data), label)
   

3. 将 DataFrame 分为两部分：

   parts <- h2o.splitFrame(data, 0.8)
   

将使用一个 DataFrame 进行训练，而另一个将用于测试/验证正在训练的模型。parts <- h2o.splitFrame(data, 0.8)将 DataFrame 分为两部分。一个 DataFrame 包含 80%的数据，而另一个包含剩余的 20%。现在，将包含 80%数据的 DataFrame 指定为训练 DataFrame，另一个指定为测试或验证 DataFrame。

1. 将第一部分指定为训练 DataFrame：

   train_dataframe <- parts[[1]]
   

2. 将第二部分指定为测试 DataFrame：

   test_dataframe <- parts[[2]]
   

3. 现在数据集已经导入，其特征和标签也已识别，让我们将它们传递给 H2O 的 AutoML 以训练模型。这意味着你可以在 R 中使用h2o.automl()函数实现 AutoML 模型训练功能。使用 H2O AutoML 训练模型：

   aml <- h2o.automl(x = features, y = label, training_frame = train_dataframe, max_models=10, seed = 1)
   

4. 提取 AutoML 排行榜：

   model_leaderboard <- aml@leaderboard
   

5. 显示 AutoML 排行榜：

   print(model_leaderboard, n = nrow(model_leaderboard))
   

一旦训练完成，AutoML 将创建一个排行榜，列出它所训练的所有模型，从表现最好的到最差的进行排名。

排行榜将按以下方式显示结果：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_01_006.jpg

图 1.6 – H2O AutoML 排行榜（R）

排行榜包括我们在 Python 中训练模型时看到的排行榜上的相同详细信息。

然而，你可能注意到这个排行榜中建议的最佳模型与我们之前的实验中得到的模型不同。

在这种情况下，GBM_3_AutoML_8_20211222_02555 是 H2O AutoML 认定的最佳模型，而在之前的实验中，它是 GLM_1_AutoML_1_20211221_224844。这可能是由于几个因素造成的，例如在模型训练过程中种子值生成了不同的随机数，或者两个实验之间在训练和测试 DataFrame 中分割的数据值不同。这就是机器学习复杂的地方——你在模型训练流程中执行的每一步都可能极大地影响你训练的模型的整体性能。最终，机器学习是一种力求做出最准确预测的最佳努力方法。

恭喜你 – 你已经正式使用 R 中的 H2O AutoML 训练了你的机器学习模型。现在，让我们学习如何对其做出预测。我们将使用在分割函数之后创建的测试 DataFrame 对我们训练的模型进行预测。

在 R 中执行以下命令进行预测：

predictions <- h2o.predict(aml, test_dataframe)

h2o 对象的 predict 函数接受两个参数。一个是模型对象，在我们的例子中是 aml 对象，另一个是要进行预测的 DataFrame。默认情况下，aml 对象将使用排行榜中的最佳模型进行预测。

执行预测后，你将看到以下结果：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_01_001.jpg

图 1.7 – H2O AutoML 模型预测（R）

结果显示一个表格，其中包含与我们之前用 Python 进行的实验中看到类似的详细信息。每一行都是测试 DataFrame 中现有行的预测表示。predict 列指示该行的 Iris 类别，而其余列是 Iris 类别的计算概率。

恭喜你 – 你已经使用 R 中的 AutoML 新训练的模型做出了准确的预测。现在，让我们总结本章内容。

摘要

在本章中，我们了解了机器学习流程中的各个步骤以及 AutoML 如何在自动化这些步骤中发挥作用。然后，我们通过安装基本需求来准备我们的系统以使用 H2O AutoML。一旦我们的系统准备就绪，我们就在 Python 和 R 中实现了一个简单的应用程序，该程序使用 H2O AutoML 在 Iris 花数据集上训练模型。最后，我们了解了排行榜结果，并对我们刚刚训练的机器学习模型进行了成功的预测。所有这些都帮助我们测试了 H2O AutoML 的水，从而打开了通往 H2O AutoML 更高级概念的门户。

在下一章中，我们将探索 H2O 的 Web 用户界面（UI），以便我们可以通过交互式可视化界面理解和观察各种机器学习细节。

第二章：在 H2O Flow（H2O 的 Web UI）中工作

机器学习（ML）不仅仅是代码。它涉及从不同角度的大量观察。尽管实际编码非常强大，但很多信息都隐藏在编码的终端后面。人类总是比文字更容易理解图片。同样，ML 虽然复杂，但在交互式用户界面（UI）的帮助下，可以非常容易且有趣地实现。在学习困难主题时，在单调的黑白像素化终端上使用彩色的 UI 总是加分。

H2O Flow是由 H2O.ai 团队开发的一个基于 Web 的 UI。这个界面运行在我们已经在第一章的理解 H2O AutoML 基础部分中了解到的相同后端。它只是将主 H2O 库包装成一个 Web UI，在后端服务器上传递输入并触发函数，并通过将结果显示给用户来读取结果。

在本章中，我们将学习如何使用 H2O Flow。我们将执行 ML 管道的所有典型步骤，这些步骤我们在第一章的理解 AutoML 和 H2O AutoML部分中已经了解，即理解 H2O AutoML 基础，从读取数据集到使用训练好的模型进行预测。此外，我们还将探索一些指标和模型细节，以帮助我们更容易地进入更高级的主题。本章是实践性的，我们将在创建我们的 ML 管道时了解 H2O Flow 的各个部分。

到本章结束时，你将能够导航和使用 H2O Flow 的各种功能。此外，你将能够使用 H2O Flow 训练你的 ML 模型，并用于预测，而无需编写任何代码。

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

• 理解 H2O Flow 的基础

• 在 H2O Flow 中处理数据函数

• 在 H2O Flow 中处理模型训练函数

• 在 H2O Flow 中处理预测函数

技术要求

你将需要以下内容：

• 一个不错的 Web 浏览器（Chrome、Firefox 或 Edge），你首选 Web 浏览器的最新版本。

理解 H2O Flow 的基础

H2O Flow 是一个开源的 Web 界面，它帮助用户在单个称为Flow 笔记本或简称Flow的页面上执行代码、绘制图表和显示数据框。

Jupyter 笔记本的用户会发现 H2O Flow 非常相似。你可以在单元格中编写可执行代码，当你执行单元格时，代码的输出会显示在其下方。然后，光标会移动到下一个单元格。Flow 最好的地方在于它可以很容易地保存、导出和导入到各种用户之间。这有助于许多数据科学家在各个利益相关者之间共享结果，因为他们只需保存执行结果并分享流程。

在以下子节中，我们将了解 H2O Flow 的基础知识。让我们从下载 H2O Flow 到我们的系统开始我们的 H2O Flow 之旅。

下载和启动 H2O Flow

为了运行 H2O Flow，您需要首先将 H2O Flow 的 Java 归档（JAR）文件下载到您的系统上，然后下载完成后运行该 JAR 文件。

您可以使用以下步骤下载并启动 H2O Flow：

1. 您可以从 h2o-release.s3.amazonaws.com/h2o/master/latest.xhtml 下载 H2O Flow。

2. 一旦 ZIP 文件下载完成，打开终端，在下载 ZIP 文件的文件夹中运行以下命令：

   unzip {name_of_the_h2o_zip_file}
   

3. 要运行 H2O Flow，请在解压缩后的 h2o 文件夹内运行以下命令：

   java -jar h2o.jar
   

这将在 localhost:54321 上启动 H2O Web UI。

现在我们已经下载并启动了 H2O Flow，让我们简要地探索它，以了解它提供的功能。

探索 H2O Flow

H2O Flow 是一个非常功能丰富的应用程序。它几乎拥有您创建机器学习（ML）管道所需的所有功能。考虑到机器学习（ML）管道中涉及的各个步骤，H2O Flow 为这些步骤提供了丰富的功能。这对很多人来说可能会感到不知所措。因此，探索应用程序并一次关注应用程序的特定部分是非常有价值的。

在以下章节中，我们将详细了解这些部分；然而，一些功能可能在这个阶段过于复杂，难以理解。我们将在接下来的章节中更好地理解它们。目前，我们将专注于了解如何使用 H2O Flow 创建我们的机器学习（ML）管道。

因此，让我们首先通过启动 H2O Flow 并在 localhost:54321 URL 打开您的网络浏览器来进行探索。

以下截图显示了 H2O Flow UI 的主页面：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_001.jpg

图 2.1 – H2O Flow UI 的主页面

如果您看到一些细微的差异，请不要惊慌。这可能是由于您安装的版本可能与本书中显示的不同。尽管如此，UI 的基本设置应该是相似的。正如您所看到的，有大量的交互式选项可供选择。一开始可能会有些令人不知所措，所以让我们一步一步来。

在网页的顶部，有各种机器学习对象操作，每个操作都有自己的功能下拉列表。它们如下所示：

• Flow：本节包含所有与 Flow 笔记本相关的操作。

• Cell：本节包含所有与笔记本中单个单元格相关的操作。

• Data：本节包含所有与数据处理相关的操作。

• Model：本节包含所有与模型训练和算法相关的操作。

• 评分: 这个部分包含所有与评分和预测相关的操作。

• 管理员: 这个部分包含所有管理操作，例如下载日志。

• 帮助: 这个部分包含所有指向 H2O 文档的链接，以获取更多详细信息。

一旦我们开始创建我们的机器学习管道，我们将逐步详细地介绍它们。

以下截图显示了 H2O Flow UI 的各种机器学习功能操作：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_002.jpg

图 2.2 – 机器学习对象操作工具栏

在此之后，我们有流名称和流工具栏设置。默认情况下，流名称将是未命名流程。流名称有助于在一般情况下识别整个流程，这样你就不会混淆不同的实验。流工具栏部分是一个简单的工具栏，它帮助你进行基本操作，例如编辑和管理你流程中的单元格。

以下截图显示了主页上存在的流程工具栏：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_003.jpg

图 2.3 – 流名称和流工具栏部分

单元格是你可以逐个执行的代码执行行。它们也可以用来添加注释、标题，甚至是 Markdown 文本。

工具列表如下。我们将从左到右开始：

• 新建: 这将创建一个新的 Flow 笔记本。

• 打开: 这将打开存储在你系统中的现有 Flow 笔记本。

• 保存: 这将保存你的当前流程。

• 插入单元格: 这将在下方插入一个单元格。

• 向上移动: 这会将当前高亮的单元格向上移动到上面的单元格之上。

• 向下移动: 这将当前高亮的单元格移动到其下的单元格下方。

• 剪切: 这将剪切单元格并将其存储在剪贴板上。

• 复制: 这将复制当前高亮的单元格。

• 粘贴: 这将在当前高亮的单元格下方粘贴之前复制的单元格。

• 清除单元格: 如果有输出，这将清除单元格的输出。

• 删除单元格: 这将完全删除单元格。

• 运行并选择下方: 这将运行当前高亮的单元格，并在下面的单元格处停止。

• 运行: 这将运行当前高亮的单元格。

• 运行所有: 这将逐个从上到下运行所有单元格。

• 协助我: 这将执行一个协助命令，通过显示基本机器学习命令的链接来帮助你。

在你的流程的右侧有额外的支持选项，帮助你管理你的工作流程。你有概要、流程、剪辑和帮助。每个选项都有自己的列，包含功能细节。

以下截图显示了 H2O Flow UI 的各种支持选项：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_004.jpg

图 2.4 – 支持选项

概述列显示了您执行的所有操作的列表。查看概述可以帮助您快速检查在创建您的机器学习管道时执行的步骤是否按正确顺序排列，是否有任何重复，或者是否有任何错误的步骤。

以下截图显示了概述支持选项部分：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_005.jpg

图 2.5 – 概述

流程列显示了您之前保存的所有流程。目前，您不会有任何，但一旦您保存了流程，它将在这里显示，并提供快速链接以打开它。请注意，在 H2O Flow 页面上一次只能打开一个 Flow 笔记本。如果您想同时处理多个流程，可以通过打开另一个标签页并在那里打开 Flow 笔记本来实现。

以下截图显示了流程支持选项部分：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_006.jpg

图 2.6 – 保存的流程

CLIPS列是您的剪贴板。如果您在流程中要多次运行的任何代码，则可以一次性编写并保存到剪贴板，方法是选择单元格右侧的纸夹图标。然后，您可以在需要时粘贴该单元格，而无需在流程中搜索它。剪贴板还存储了一定数量的垃圾单元格。

以下截图显示了CLIPS支持选项部分：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_007.jpg

图 2.7 – 剪贴板

帮助列显示了各种资源，以帮助用户使用 H2O Flow。这包括快速入门视频、示例流程、一般使用示例以及指向官方文档的链接。请随意探索这些资源，以了解您如何使用 H2O Flow。

以下截图显示了帮助支持选项部分：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_008.jpg

图 2.8 – 帮助部分

返回页面顶部，让我们探索前两个下拉列表。它们足够简单，易于理解。

以下截图显示了操作的第一下拉列表，即流程对象操作：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_009.jpg

图 2.9 – 流程函数下拉列表

流程操作的下拉列表在一般意义上具有基本功能。您可以创建新的流程、打开现有的流程、保存、复制、运行流程中的所有单元格、清除输出以及下载流程。下载流程非常有用，因为您可以将您的机器学习工作轻松地从流程转移到其他系统。

在右侧是单元对象操作下拉列表（如图图 2.10所示）。这个下拉列表也易于理解。它具有操作流程中各种单元格的基本功能。通常，它针对 Flow 笔记本中突出显示的单元格。您只需点击它就可以更改突出显示的单元格：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_010.jpg

图 2.10 – 单元函数下拉列表

我们将在开始构建我们的机器学习流程时探索其他选项。

在本节中，我们了解了 H2O Flow 是什么，如何下载它，以及如何在本地启动它。此外，我们还探索了 H2O Flow UI 的各个部分以及它提供的各种功能。现在我们已经熟悉了我们的环境，让我们更深入地了解并创建我们的机器学习（ML）流程。我们将从流程的第一个部分开始，即处理数据。

在 H2O Flow 中与数据函数一起工作

机器学习流程始终从数据开始。您收集的数据量以及数据的质量在训练最高质量模型时起着非常关键的作用。如果数据的一部分与另一部分没有关系，或者如果存在大量不相关的噪声数据，那么模型的品质将相应降低。因此，在训练任何模型之前，我们通常会在将数据发送到模型训练之前对数据进行几个处理过程。H2O Flow 在其数据操作下拉列表中提供了所有这些过程的接口。

我们将逐步了解各种数据操作以及使用 H2O Flow 构建机器学习流程时的输出情况。

因此，让我们首先通过导入一个数据集来开始创建我们的机器学习流程。

导入数据集

本章我们将使用的数据集将是“心力衰竭预测”数据集。您可以在www.kaggle.com/fedesoriano/heart-failure-prediction找到心力衰竭预测数据集的详细信息。

这是一个包含有关个体胆固醇、最大心率、心绞痛和其他属性的健康信息的数据集，这些属性是判断一个人是否可能经历心力衰竭的重要指标。

让我们了解数据集的内容：

• Age: 患者的年龄，单位为年

• Sex: 患者的性别；男性为 M，女性为 F

• ChestPainType:

  • 类型如下列出：

    • TA: 典型心绞痛

    • ATA: 不典型心绞痛

    • NAP: 非心绞痛疼痛

    • ASY: 无症状

• RestingBP: 休息时的血压，单位为[毫米汞柱]

• Cholesterol: 血清胆固醇，单位为[毫米/分升]

• FastingBS: 空腹血糖，如果空腹血糖大于 120 mg/dl，则为 1，否则为 0

• RestingECG: 休息时的心电图结果

  • 类型如下列出：

    • Normal: 正常

    • ST: 存在 ST-T 波异常

    • LVH：根据 Estes 标准，显示可能或确定的左心室肥厚

• MaxHR：达到的最大心率值，介于 60 和 202 之间

• ExerciseAngina：运动诱导的心绞痛；Y 表示是，N 表示否

• Oldpeak：ST（在下降时测量的数值）

• ST_Slope：峰值运动 ST 段的斜率

  • 类型如下：

    • 上升：向上倾斜

    • Flat：平坦

    • 下降：向下倾斜

• HeartDisease：输出类别，其中 1 表示心脏病，0 表示无心脏病

我们将使用此数据集训练一个模型，尝试预测具有某些属性的人是否有面临心脏衰竭的潜力。请执行以下步骤：

1. 首先，让我们开始使用 H2O Flow 导入此数据集。

2. 在网页用户界面的最顶部，您可以看到 数据 对象操作的下拉列表。

3. 点击它，网页用户界面应显示如下截图所示的输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_011.jpg

图 2.11 – 数据对象下拉列表

下拉列表显示您可以执行的所有各种操作列表，以及与您将要处理的数据相关的那些操作。

函数列表如下：

• 导入文件：此操作导入存储在您系统中的文件。它们可以是任何可读的文件，可以是 逗号分隔值（CSV）格式或 Excel 格式。

• 导入 SQL 表：如果您使用 SQL 数据库存储任何表格数据，此操作允许您导入存储在您的 结构化查询语言（SQL）表中的数据。当您点击它时，您将被提示输入您的 SQL 数据库的 连接 URL 值，以及其凭据、表名称、列名称，以及选择 获取模式 的选项，可以是 分布式 或 单机，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_012.jpg

图 2.12 – 导入 SQL 表

• 上传文件：此操作从您的系统上传单个文件并立即解析它。

• 分割框架：此操作将已由 H2O Flow 导入和解析的数据框架分割成多个框架，您可以使用这些框架进行多个实验。

• 合并框架：此操作将多个框架合并为一个。当您点击它时，您将被提示选择右侧和左侧框架及其相应的列。此外，您可以选择包含在合并中的哪个框架的哪些行，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_013.jpg

图 2.13 – 合并框架

• 列出框架：此操作列出所有当前由 H2O 导入和解析的框架。如果您想要在不同的数据集上运行您的管道，这很有帮助，这些数据集之前已被您导入或拼接。

• 填充：填充是将数据集中缺失的值替换为平均值的过程，这样它不会引入任何偏差，最小化值，最大化值，甚至空值。此操作允许你根据你的偏好替换你的框架中的这些值。

因此，首先，让我们导入Heart Failure Prediction数据集。

执行以下步骤：

1. 点击数据操作下拉列表。

2. 点击导入文件…。你应该会在你的流程中看到一个单元格上的操作被执行，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_014.jpg

图 2.14 – 导入文件

你也可以通过在单元格中键入importFiles并按Shift + Enter直接运行相同的命令，而不是使用下拉列表。

1. 在搜索栏中，添加你已下载数据集的文件夹位置。

2. 点击最右侧的搜索按钮。这将显示文件夹中的所有文件，你可以选择要导入的文件。

3. 选择heart.csv数据集，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_015.jpg

图 2.15 – 使用输入导入文件

1. 一旦你选择了文件，点击导入按钮。然后 H2O 将导入数据集并显示如下输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_016.jpg

图 2.16 – 导入的文件

恭喜！你现在已成功将你的数据集导入到 H2O Flow 中。下一步是将它解析成逻辑格式。让我们了解什么是解析以及我们如何在 H2O Flow 中完成它。

解析数据集

解析是将数据集中的信息字符串分析并加载到逻辑格式中的过程，在这种情况下，是一个hex文件。hex 文件是一种内容以十六进制格式存储的文件。H2O 在内部使用此文件类型进行数据框操作并维护数据集的元数据。

让我们通过执行以下步骤来解析新导入的数据集：

1. 在导入数据集后，点击**解析这些文件…**按钮，如图图 2.16所示。

以下截图显示了你应该期望的输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_017.jpg

图 2.17 – 数据集解析输入

1. 然后，你将被提示输入hex文件。在解析过程中，你可以从以下配置中选择：

   • 来源：此配置表示你将要解析的数据集的来源。

   • ID：此配置表示数据集的 ID。你可以更改将要创建的 hex 文件的 ID。

   • 解析器: 此配置设置用于解析数据集的解析器。您将使用不同的解析器来解析不同类型的数据集。例如，如果您正在解析 Parquet 文件，那么您需要选择 Parquet 文件解析器。在我们的情况下，我们正在解析 CSV 文件；因此，选择CSV解析器。您也可以将其设置为自动，H2O 将自行识别需要解析指定文件所需的解析器。

   • 分隔符: 此配置用于指定分隔数据集中值的分隔符。让我们将其保留为默认值，,:’004’，这是一个非常常见的 CSV 分隔符值。

   • 转义字符: 此配置用于指定数据集中使用的转义字符。让我们将其保留为默认值。

   • 列标题: 此配置用于指定数据集的第一行是否包含列名。H2O 将使用此信息来处理第一行，要么将其用作列信息，要么自动生成列名并使用第一行作为数据值。此外，您可以将值设置为自动，让 H2O 自行识别数据集的第一行是否包含列名。我们的数据集的第一行是列名，所以让我们选择第一行包含列名。

   • 选项: 此配置包含以下附加操作：

     • 启用单引号作为字段引号字符: 此选项启用单引号作为字段引号字符。

     • 完成时删除: 此选项在成功解析后删除导入的数据集。让我们勾选此选项，因为我们一旦成功解析就不会再需要导入的数据集。

2. 在解析配置部分下方，您有编辑列名和类型部分（见图 2.18）。在解析数据集之前，H2O 读取数据集并显示列名和它们提取的信息类型的简要摘要。这给了您编辑列名和类型的选择，以防它解释错误或您希望将列名更改为不同的名称。

以下截图显示了列名和解析数据集时编辑它们类型的选项：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_018.jpg

图 2.18 – 编辑列类型

现在，让我们简要了解列的类型，如前一个截图所示：

它们可以列出如下：

• 数值: 这表示该列中的值是数字。

• 枚举: 这表示该列中的值是枚举类型（Enums）。枚举是一组命名的非数值有限值集合。

• 时间: 这表示该列中的值是日期时间数据类型的值。

• UUID: 这表示该列中的值是通用唯一标识符（UUIDs）。

• 字符串：这表示列中的值是字符串值。

• 无效：这表示列中的值无效，这意味着列中的值存在问题。

• 未知：这表示列中的值是未知的，这意味着列中没有值。

在训练过程中，H2O 根据列的类型不同对待数据框的列。有时，它会错误地解释列的值，并将错误的列类型分配给列。看看数据集的列及其对应类型。你可能会注意到，在导入数据集后，我们的HeartDisease输出列的类型是数值型。H2O 读取了 1 和 0，并假设它的类型是数值型。但实际上，它是一个枚举值，因为 1 表示心脏病，0 表示无心脏病。中间没有数值。我们在解析数据集时始终需要小心。我们需要确保在开始在该数据集上训练模型之前，H2O 正确地解释了数据集。H2O Flow 提供了一个在解析之前纠正这个问题的简单方法。

接下来，让我们纠正列的类型：

1. 选择HeartDisease列名旁边的下拉列表，将其设置为枚举。

2. 同样，FastingBS将被设置为数值型，但实际上，它是一个基于其描述的枚举值。所以，让我们将其设置为枚举。

3. 现在我们已经纠正了列的类型，并选择了正确的解析配置，让我们解析数据集。点击输出底部的解析按钮。

以下截图显示了解析后的输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_019.jpg

图 2.19 – 解析输出

现在，让我们观察从上一个截图得到的输出：

• 运行时间：这个输出显示了从 H2O 开始解析数据集以来的运行时间。

• 剩余时间：这个输出显示了 H2O 完成解析数据集预计所需的时间。

• 类型：这个输出显示了解析文件的类型。

• 键：这个输出显示了一个链接到十六进制文件，该文件是在成功解析后生成的。

• 描述：这个输出显示了当前正在进行的操作。

• 状态：这个输出显示了操作当前的状态。

• 进度：这个输出显示了操作的进度条。

• 操作：这个输出是一个按钮，显示在成功解析数据集后生成的十六进制文件。

恭喜！你已经成功解析了你的数据集，并生成了十六进制文件。十六进制文件通常被称为数据框。现在我们已经生成了数据框，让我们看看我们可以对数据框执行的各种元数据和操作。

观察数据框

数据框是 H2O 可以执行多个数据操作的主要数据对象。此外，H2O 还提供了关于数据框内容的详细见解和统计数据。当处理非常大的数据框时，这些见解特别有帮助，因为很难确定任何列中是否存在缺失值或零，而数据行可以从数千到数百万不等。

因此，让我们观察我们刚刚解析的数据框并探索其功能。您可以通过执行以下操作之一从我们在图 2.19中看到的解析输出中查看数据框：

• 在键行中单击heart.hex超链接。

• 在操作行中单击查看数据按钮。

以下截图显示了之前提到的操作的输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_020.jpg

图 2.20 – 查看数据框

输出显示了数据框的摘要。在探索操作部分的各种操作之前，首先让我们探索下面的数据框元数据。

元数据包括以下内容：

• 行数：显示数据集中的行数。

• 列数：显示数据集中的列数。

• 压缩大小：显示数据框的总压缩大小。

在元数据下方，您有列摘要部分。在这里，您可以查看数据框内容的统计数据，这些数据按列划分。

摘要包含以下信息：

• 标签：此列显示了数据框列的名称。

• 类型：此列显示了列的类型。

• 缺失：此列显示了该列中缺失值的数量。

• 零：此列显示了该列中的零的数量。

• +Inf：此列显示了正无穷值的数量。

• -Inf：此列显示了负无穷值的数量。

• min：此列显示了该列的最小值。

• max：这显示了该列的最大值。

• sigma：此列显示了该列值的变异性。

• 基数：此列显示了该列中唯一值的数量。

• 操作：此列显示了可以在数据框的列上执行的一些操作。这些操作主要涉及将列转换为不同类型。如果 H2O 在解析后错误地读取了列类型，这非常有用。

你可能想知道为什么在Sex和RestingECG等列的Zeros列中看到了很多值。这是因为编码。当解析枚举列时，H2O 将枚举和字符串编码成从 0 开始的数值，然后是 1，接着是 2，以此类推。你也可以通过选择你想要的编码过程来控制这个编码过程，例如，标签编码或独热编码。我们将在第五章中更详细地讨论编码，理解 AutoML 算法。

在COLUMN SUMMARIES部分之后，你会看到CHUNK COMPRESSION SUMMARY部分，如下截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_021.jpg

图 2.21 – 数据集的 CHUNK COMPRESSION SUMMARY 部分

当使用非常大的数据集时，如果以传统方式读取和写入数据，可能会花费很长时间。因此，系统如 Hadoop 文件系统、Spark 等经常被使用，因为它们以分布式方式执行读写，比传统的连续方式更快。分块是一个过程，其中分布式文件系统如 Hadoop 将数据集分割成块并在写入磁盘之前将它们展平。H2O 内部处理所有这些，这样用户就不需要担心管理分布式读写。CHUNK COMPRESSION SUMMARY部分只是提供了关于块分布的额外信息。

在CHUNK COMPRESSION SUMMARY下方是FRAME DISTRIBUTION SUMMARY部分，如下截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_022.jpg

图 2.22 – 数据集的 Frame Distribution Summary 部分

FRAME DISTRIBUTION SUMMARY部分提供了关于数据框的一般统计信息。如果你导入了多个文件并将它们解析成一个单一的数据框，那么框架分布摘要将计算总大小、平均大小、最小大小、最大大小、每个数据集的块数等等。

回顾一下图 2.20中的数据框，你可以看到列名被突出显示为链接。让我们点击最后一个列，HeartDisease。

下面的截图将展示HeartDisease列的列摘要：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_023.jpg

图 2.23 – 列摘要

列摘要根据列的类型提供了关于数据集中各个列的更多详细信息。

对于像HeartDisease这样的枚举类型，它会显示如下列的详细信息：

• 特征：此图表显示了零值和非零值的百分比分布。

• 域：此图表显示了列的域，即一个值在总行数中被重复的次数。

当你将鼠标悬停在图表上时，你会看到更多详细信息。请随意探索所有列并尝试理解它们的特征。

返回到图 2.20的 dataframe，现在让我们看看操作部分。这包括可以在 dataframe 上执行的一些操作。

这些操作包括以下内容：

• 查看数据：此操作显示 dataframe 中的数据。

• 分割：此操作将 dataframe 按指定的比例分割成指定的部分。

• 构建模型：此操作在此 dataframe 上开始构建模型。

• 运行 AutoML：此操作会在 dataframe 上触发 AutoML。

• 预测：此操作使用 dataframe 在已训练的模型上进行预测并获取结果。

• 下载：此操作将 dataframe 下载到系统中。

• 导出：此操作将 dataframe 导出到系统中的指定路径。

尽管我们很兴奋要触发 AutoML，但让我们继续探索 dataframe 的各种功能。

现在，让我们看看 dataframe 及其实际的数据内容。为此，请在操作部分的查看数据按钮上点击。

以下截图显示了点击查看数据按钮的输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_024.jpg

图 2.24 – dataframe 的内容视图

此功能显示数据集的实际内容。你可以向下滚动以查看 dataframe 的所有内容。如果你在 dataframe 上执行了任何操作，那么你可以使用此操作查看 dataframe 内容的变化。

现在你已经探索并理解了 dataframe 的各种操作和数据元数据，让我们调查另一个有趣的 dataframe 操作，称为分割。

分割 dataframe

在我们将 dataframe 发送进行模型训练之前，我们需要一个包含预测值的样本 dataframe。这个样本可以用来验证模型是否做出正确的预测，并衡量模型的准确性和性能。我们可以通过保留 dataframe 的一小部分用于后续验证来实现这一点。这就是分割功能出现的地方。

分割，正如其名所示，将数据集分割成我们可以后来用于不同操作的部分。数据集的分割会考虑比例。H2O 根据你想要进行的分割数量和数据分布的比例创建多个 dataframe。

要分割 dataframe，请在操作部分的分割操作按钮上点击。

以下截图显示了点击分割按钮的输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_025.jpg

图 2.25 – 分割 dataframe

在前面的输出中，你将被提示输入分割配置，如下所示：

• 框架：此配置允许你选择要分割的框架。

• training_dataframe比例为 0.70

• validation_dataframe，比例为 0.20

• testing_dataframe，比例为 0.10

• 种子：此配置允许您选择随机化点。分割不是线性分割数据框。它随机分割数据框的行。这是好事，因为它在分割的数据框之间均匀分配数据，从而消除了数据集行序列中可能存在的任何偏差。在我们的演示中，让我们将种子值设置为 5。

一旦你进行了这些更改，点击创建按钮。这将生成三个数据框：training_dataframe、validation_dataframe和testing_dataframe。这三个框架将存储在 H2O 的本地存储库中，也可以用于其他实验。

以下图表显示了创建操作的结果：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_026.jpg

图 2.26 – 分割数据集结果

这三个数据框都是独立的数据框，它们具有与你在图 2.20中看到的原始数据集相同的特征和选项。分割不会删除原始数据框。它创建新的数据框，并将原始数据框中的数据根据所选比例分配到这些数据框中。

现在我们已经准备好了训练框架、验证框架和测试框架，我们就可以进入模型训练管道的下一步，即模型训练。

因此，为了总结，在本节中，你了解了可以在 H2O Flow 中执行的多种数据操作，例如导入、解析、读取解析后的数据框以及分割它。

在下一节中，我们将专注于模型训练，并使用 H2O AutoML 在我们在本节中创建的数据框上训练模型。

在 H2O Flow 中与模型训练函数一起工作

一旦您的数据集准备就绪，模型训练管道的下一步就是实际的训练部分。模型的训练可能非常复杂，因为有许多配置决定了模型如何在数据集上训练。即使在 AutoML 中，大多数超参数调整也是在幕后完成的，这也是事实。不仅对于特定类型的数据，训练模型有正确和错误的方法，而且一些配置值也可能影响模型的表现。因此，了解 H2O 在训练模型时提供的各种配置参数非常重要。在本节中，我们将专注于了解这些参数是什么，以及它们在模型训练中的具体作用。

我们将通过使用我们之前创建的数据框，逐步了解如何使用 AutoML 训练模型。

注意，在这个部分有很多东西在这个阶段理解起来会过于复杂。我们将在未来的章节中探讨其中的一些。目前，我们将只关注我们现在可以理解的功能，因为本章的目标是理解 H2O Flow 以及如何使用 AutoML 通过 H2O Flow 训练模型。

在接下来的子章节中，我们将了解模型训练操作，从了解 AutoML 训练配置参数开始。

理解 H2O Flow 中的 AutoML 参数

H2O AutoML 在如何训练模型方面具有极高的可配置性。尽管使用相同的 AutoML 技术，但每个行业通常都会根据其需求对如何训练模型有一定的偏好或倾向。因此，尽管 AutoML 正在自动化大多数 ML 过程，但在 AutoML 如何训练模型方面仍需要一定程度的控制和灵活性。H2O 为其 AutoML 功能提供了广泛的配置能力。让我们在训练模型时探索它们。

有两种方式可以在数据集上触发 AutoML。它们如下列出：

• 通过点击数据框输出操作部分的运行 AutoML按钮，如图图 2.20所示。

• 通过在模型部分的下拉菜单中选择运行 AutoML，在网页 UI 的最顶部，如图图 2.27所示。

我们选择第二个选项，以便我们可以探索网页 UI 页面顶部的模型操作部分。当你点击模型部分时，你应该会看到一个下拉列表，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_027.jpg

图 2.27 – 模型功能下拉列表

上述下拉列表将模型操作分为三种类型，如下所示：

• 运行 AutoML：这个操作通过提示用户输入配置值来启动 AutoML 过程，以使用 AutoML 训练模型。

• 运行特定模型：这个操作在特定的 ML 算法上启动模型训练，这些算法是你希望使用的；例如，深度学习、K-means 聚类、随机森林等。每个 ML 算法都有一组你必须指定的参数，以启动模型训练。

• 模型管理选项：这些操作是用于管理你在一段时间内可能训练过的各种模型的基本操作。

  • 操作列表如下：

    • 导入 MOJO 模型：这个操作导入之前由另一个 H2O 服务训练并导出为 MOJO 格式的 H2O 模型对象，优化（MOJO）模型。

    • 列出所有模型：这个操作列出由你的 H2O 服务训练的所有模型。这包括由其他 Flow 笔记本训练的模型。

    • 列出网格搜索结果：网格搜索是一种在训练模型以获得最佳和最准确性能时寻找最佳超参数的技术。此操作列出从模型训练中获取的所有网格搜索结果。

    • 导入模型：此操作将模型对象导入到 H2O 中。

    • 导出模型：此操作将模型对象导出到系统，可以是二进制文件或 MOJO 格式。

现在，让我们使用 AutoML 在我们的数据集上训练我们的模型。

点击运行 AutoML。如图 2.27 所示，您应该看到一个提示您输入各种配置参数以运行 AutoML 的输出。有大量的选项可以配置您的 AutoML 训练。这些选项可以极大地影响您的模型训练性能以及最终训练出的模型质量。参数被分为三类。让我们逐一探索它们，并从基本参数开始，输入适合我们模型训练要求的值。

基本参数

基本参数是那些关注所有模型训练操作所需的基本输入的参数。这些参数在所有机器学习算法中都是通用的，并且是自我解释的。

以下截图显示了您需要输入以配置 AutoML 的基本参数值：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_028.jpg

图 2.28 – AutoML 的基本参数

基本参数如下所示：

• training_frame参数是我们创建在使用 H2O Flow 中的数据函数部分中的training_dataframe.hex文件。

• HeartDisease列。

• 我们在上一节中创建的validation_dataframe.hex文件。

• blending_frame：此配置设置用于训练堆叠集成模型的 dataframe。目前，我们可以忽略这一点，因为我们不会在本章中深入探讨堆叠集成。我们将在第五章“理解 AutoML 算法”中更详细地探讨堆叠集成模型，所以让我们留空。

• 将nfolds设置为 0，然后 AutoML 将从训练框架生成排行榜。

• 项目名称：此配置设置您的项目名称。AutoML 将所有多次运行的结果组合到单个排行榜下，该排行榜以项目名称命名。如果您留空此值，H2O 将自动为其生成一个随机项目名称。

• 分布：此配置用于指定机器学习算法将使用的分布函数类型。支持指定类型分布函数的算法将使用它，而其他算法将使用它们的默认值。我们将在第五章“理解 AutoML 算法”中了解更多关于分布函数的内容。

现在您已经了解了 AutoML 的基本参数，让我们来了解高级参数。

高级参数

高级参数为使用 AutoML 训练模型提供了额外的配置。这些参数已经设置了某些默认值，因此不是必需的。然而，它们确实提供了额外的配置，这些配置会改变 AutoML 在训练模型时的行为。

下面的截图显示了 AutoML 的高级参数的第一部分：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_029.jpg

图 2.29 – AutoML 高级参数，第一部分

立即在这之下将是高级参数的第二部分。向下滚动查看剩余的参数，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_030.jpg

图 2.30 – AutoML 高级参数，第二部分

让我们逐一探索这些参数。高级参数如下所示：

• fold_column：此参数使用列值作为其 N 折交叉验证中折叠的基础。我们将在接下来的章节中学习更多关于交叉验证的内容。

• weights_column：此参数为训练数据框中的某一列赋予权重，或者简单地说，给予该列优先权。我们将在后面的章节中更详细地探讨模型训练中的权重问题。

• ignored_columns：此参数允许您选择在训练模型时希望忽略的训练数据框中的列。在我们的实验中，我们不会忽略任何列，所以我们将保留所有列未选中。

• sort_metrics：此参数选择 AutoML 训练的模型将使用的排序和排名指标。选择AUTO将使用AUC指标进行二分类，mean_per_class_error用于多项式分类，以及deviance用于回归。为了简化起见，让我们将均方误差（MSE）设置为排序指标，因为它更容易理解。我们将在第六章中更详细地探讨指标，理解 H2O AutoML 排行榜和其他性能指标。

• 0 用于防止创建堆叠集成模型。我们将在接下来的章节中进一步探讨堆叠集成模型和交叉验证。

• Balance_classes: 在模型训练中，始终最好在具有输出类别值均匀分布的数据集上训练模型。这可以减轻由于值分布不均可能产生的任何偏差。此参数平衡输出类别，使其数量相等。在我们的案例中，输出类别是心脏病列。正如我们在心脏病列的列摘要中看到的，在分布部分，我们有大约 410 个值为 0，508 个值为 1（见图 2.23）。因此，理想情况下，我们需要在训练模型之前平衡类别。然而，为了简化当前的操作，我们将跳过类别的平衡，专注于理解基础知识。我们将在接下来的章节中进一步探讨类别平衡。

• exclude_algos: 此参数排除 AutoML 训练中的某些算法。在我们的实验中，我们希望考虑所有算法，所以让我们将值留空。

• -1保持原样。

• monotone_constraints: 在某些情况下，如果对特征之间关系有非常强烈的先验信念，认为它们具有某种性质，可以使用约束来提高模型的预测性能。此参数有助于设置这些约束。我们将在接下来的章节中进一步讨论这个问题。现在，让我们将此值留空。

• 5。

• 10，否则模型训练可能会花费很长时间。

• max_runtime_secs: 此参数设置 H2O 在训练单个模型上应花费的最大时间。通常，数据集的大小越大，模型训练所需的时间就越长。为模型训练设置非常短的时间将不会给 AutoML 足够的时间来训练模型。由于我们的数据集不是很大，我们将让 AutoML 有足够的时间来训练模型，这不应该花很长时间。

• max_runtime_sec_per_model: 此参数设置 AutoML 在训练单个模型上应花费的最大时间。模型训练不会花费太多时间。所以，让我们忽略这个参数。

• 0以禁用它。

• stopping_metrics: 此指标用于早期停止。由于停止功能被禁用，我们将忽略此参数。

• stopping_tolerance: 这指的是在渐进式模型训练中，当预期改进的相对容忍度低于此值时，AutoML 应停止训练模型。由于停止功能被禁用，我们将忽略此参数。

现在你已经了解了 AutoML 的基本参数，让我们检查专家参数。

专家参数

专家参数是提供额外选项的参数，这些选项通过添加有助于进一步实验的额外功能来补充 AutoML 训练结果。这些参数取决于你在高级参数部分已选定的配置。

以下截图显示了当前演练中可用的专家参数选项：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_031.jpg

图 2.31 – AutoML 专家参数

专家参数如下列出：

• keep_cross_validation_predictions：如果训练启用了交叉验证，那么 H2O 提供了保存那些预测值的选项。

• keep_cross_validation_models：如果训练启用了交叉验证，那么 H2O 提供了保存用于相同训练的模型的选项。

• keep_cross_validation_fold_assignments：如果训练启用了交叉验证，那么 H2O 提供了保存用于不同交叉验证中模型训练的折的选项。

• export_checkpoint_dir：这是 H2O 将存储生成的模型的目录路径。

根据你在基本和高级参数中选择的内容，将提供更多专家选项。目前，我们可以禁用所有专家参数，因为我们在这个教程中不会过多关注它们。

一旦你设置了所有参数值，现在剩下的唯一事情就是触发 AutoML 模型训练。

在 H2O Flow 中使用 AutoML 训练和了解模型

模型训练是机器学习管道中最复杂和最重要的部分之一。模型训练是通过学习特征与预期输出之间的关系，通过最小化损失来映射数学近似的过程。你可以用各种方法来做这件事。系统执行此任务的方法被称为机器学习算法。AutoML 使用各种机器学习算法来训练模型，并比较它们的性能，以找到根据机器学习问题具有最小误差度量值的模型。

首先，让我们了解如何在 H2O Flow 中使用 AutoML 训练模型。

在 H2O Flow 中使用 AutoML 训练模型

当设置使用 AutoML 训练模型的参数值时，你需要仔细考虑。一旦你选择了正确的输入，你就可以触发 AutoML 模型训练。

你可以通过点击构建模型按钮在运行 AutoML输出的末尾来完成此操作。

以下截图显示了 AutoML 训练作业的进度：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_032.jpg

图 2.32 – AutoML 训练已完成

训练模型需要一些时间。模型训练的结果存储在排行榜上。键部分的值是排行榜的链接（见图 2.32）。

你可以通过以下两种方式之一查看排行榜。它们如下列出：

• 点击 AutoML 训练作业输出中的键部分中的排行榜链接。

• 点击 AutoML 训练作业输出的查看按钮。

在以下截图中，你可以看到排行榜的样子：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_033.jpg

图 2.33 – AutoML 排行榜

如果您遵循了前面示例中显示的相同步骤，那么您应该看到相同的输出，尽管模型的 ID 可能略有不同，因为它们是随机生成的。排行榜显示了 AutoML 训练的所有模型，并根据排序指标从最好到最差进行排名。排序指标是衡量模型质量的一种统计测量，用于比较不同模型的性能。此外，排行榜还包含所有单个模型详情的链接。您可以选择其中的任何一个来获取有关单个模型的更多信息。如果 AutoML 正在运行并正在训练模型，您还可以通过点击实时监控按钮来实时查看训练进度。

现在您已经了解了如何使用 AutoML 训练模型，让我们深入探讨机器学习模型细节，并尝试理解其各种特性。

理解机器学习模型

一个机器学习模型可以被描述为一个包含数学方程式的对象，该方程式可以识别给定特征集的模式并预测潜在的输出。这些机器学习模型构成了所有机器学习管道的核心组件，因为整个机器学习管道的目标是创建和使用这些模型进行预测。因此，了解训练好的机器学习模型的各个方面细节对于判断其做出的预测是否准确以及准确程度如何至关重要。

让我们点击排行榜上的最佳模型，以了解其更多细节。您应该看到以下输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_034.jpg

图 2.34 – 模型信息

如您所见，H2O 提供了对模型细节的非常深入的视图。所有细节都分类在其各自的子节中。这里有很多信息，因此可能会让人感到不知所措。目前，我们将只关注重要的部分。

让我们逐一浏览重要且易于理解的细节：

• 模型 ID：这是模型的 ID。

• 算法：这表示用于训练模型的算法。

• 操作：一旦模型被训练，您可以对它执行以下操作：

  • 刷新：这将刷新内存中的模型。

  • 预测：这允许您开始在此模型上进行预测。

  • 下载 POJO：这将以纯旧 Java 对象（POJO）格式下载模型。

  • 下载模型部署包：这将以 MOJO 格式下载模型。

  • 导出：这将以文件或 MOJO 格式将模型导出到系统。

  • 检查：H2O 进入检查模式，其中它检查模型对象，检索有关其模式和子模式的详细信息。

  • 删除：这将删除模型。

  • 下载生成模型：这将下载生成的模型 JAR 文件。

然后，您将有一组子节，解释更多关于模型的元数据和性能。这些子节对于不同的模型略有不同，因为某些模型可能需要显示一些额外的元数据以供解释性目的。

如您所见，许多细节在本质上似乎非常复杂，这是理所当然的。这是因为它们涉及一些数据科学知识。请放心；我们将在接下来的章节中探讨所有这些内容。

让我们通过更容易的子节来了解 ML 模型的各个元数据：

• 模型参数: 模型参数不过是传递给 AutoML 的输入参数，以及 AutoML 决定用于训练模型的一些输入。您可以通过点击显示所有参数或显示修改参数按钮来选择查看所有参数或仅查看修改过的参数。每个参数的描述都显示在每个参数旁边。

• 变量重要性: 变量重要性表示变量在预测中的重要性。重要性最高的变量是 ML 模型在预测时最依赖的变量。任何对高重要性变量的更改都可能极大地影响模型预测。

以下截图显示了用于训练模型的 dataframe 中各种特征的缩放重要性：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_035.jpg

图 2.35 – 变量重要性

• 输出: 输出子节表示 AutoML 训练的基本输出值。显示的大多数细节都是交叉验证结果。

输出值如下所示：

• 模型类别: 此值表示模型的类别，表示它执行何种预测。二项式表示它执行二项式分类，这意味着它预测值是1还是0。在我们的案例中，1表示该人可能面临心脏病，而0表示该人不太可能面临心脏病。

• 开始时间: 此值表示模型训练开始的 epoch 时间。

• 结束时间: 此值表示模型训练结束时的 epoch 时间。

• 运行时间: 此值表示完成模型训练所需的总时间。

• 默认阈值: 这是模型将所有预测视为1的默认阈值。同样，低于默认阈值的任何预测值将被视为0。

以下截图显示了模型详细信息输出子节：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_036.jpg

图 2.36 – 模型信息输出

• 列类型: 本小节为您简要介绍了数据框中列的类型。这些值与训练数据框中列的顺序相同。

下面的截图显示了模型细节的列类型指标：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_037.jpg

图 2.37 – 列类型

• 输出 - 训练指标：此子部分显示了当使用训练数据集进行预测时模型的指标。我们将在未来的章节中学习有关机器学习各种指标的内容。

下面的截图显示了模型细节的训练指标：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_038.jpg

图 2.38 – 模型输出的训练指标

• 输出 - 验证指标：类似于前面的子部分，此子部分显示了当使用验证数据集进行预测时模型的指标。

下面的截图显示了模型细节的训练指标：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_039.jpg

图 2.39 – 模型输出的验证指标

现在我们已经了解了模型细节的各个部分，让我们看看我们如何可以对这个新训练的模型进行预测。

在 H2O Flow 中使用预测函数

现在你终于有一个训练好的模型了，我们可以在它上面进行预测。对训练好的模型进行预测很简单。你只需要加载模型，并传入你的数据集，该数据集包含你想要进行预测的数据。H2O 将使用加载的模型并对数据集中的所有值进行预测。让我们使用之前创建的 prediction_dataframe.hex 数据框来进行预测。

在接下来的子部分中，我们将了解预测操作，首先了解如何进行预测。

使用 H2O Flow 进行预测

首先，让我们从探索网页 UI 顶部的评分操作下拉列表开始。

你将看到以下评分操作的列表：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_040.jpg

图 2.40 – 评分函数下拉菜单

前面的下拉菜单显示了你可以执行的所有各种评分操作的列表。

函数列表如下：

• 预测：这使用训练好的模型进行预测。

• 部分依赖图：这些显示了变量对预测的影响的图形表示。换句话说，它们显示了在用于预测的数据中改变某些变量如何影响预测响应。

• 列出所有预测：此功能列出所有已进行的预测。

你可以在 H2O Flow 中开始进行预测有两种方式。如下所示：

• 使用来自评分操作下拉菜单的预测函数。

• 在模型的操作部分点击预测按钮，如图 2.34 所示。

这两种方法都会给出相同的结果，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_041.jpg

图 2.41 – 预测

点击 ML 模型的预测操作按钮将模型参数设置为相应的模型 ID。然而，当在分数操作下拉列表中点击预测操作按钮时，您可以选择任何模型。

预测操作将提示您以下参数：

• 名称：您可以给预测结果命名，以便更容易识别。如果您正在尝试不同的预测请求，并且需要快速参考您感兴趣的特定预测结果，这将特别有用。

• 模型：这是您希望用于进行预测的模型的 ID。由于我们选择了梯度提升机（GBM）模型的预测操作，这将不可编辑。

• 框架：这是您想要用于进行预测的数据框。因此，让我们选择prediction_dataset.hex文件。

• 计算叶节点分配：这返回了用于进行预测的数据框中每一行的行在模型的所有树中的叶节点位置。在我们的演示中，我们不需要这个功能，因此我们可以将其保持未选中状态。

一旦您选择了适当的参数值，剩下的唯一事情就是点击预测按钮来执行您的预测。

以下截图显示了预测操作的输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_042.jpg

图 2.42 – 预测输出

恭喜！您终于成功地在由 AutoML 训练的模型上进行了预测。让我们继续到下一部分，我们将探索和理解我们刚刚得到的预测结果。

理解预测结果

预测是机器学习流程的最终阶段。它是将实际值带给所有投入创建机器学习流程的努力的部分。进行预测很容易；然而，理解实际预测值及其与输入值的关系是很重要的。

预测结果不仅提供了预测值的详细信息，还包括指标信息和某些元数据，如图 2.42 所示。

以下截图显示了您预测结果的预测输出子部分：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_043.jpg

图 2.43 – 预测结果

这与我们在图 2.38和图 2.39中看到的模型详细信息的输出 - 验证和训练指标类似。

在这个子部分中，您可以在预测键旁边找到预测框架链接。点击它将显示您预测值的框架摘要。让我们这样做，以便我们可以更好地查看预测值。

以下截图显示了以数据框形式呈现的预测摘要详细信息：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_044.jpg

图 2.44 – 预测数据框

H2O 也将预测结果存储为数据框，因此它们具有我们在在 H2O Flow 中处理数据函数部分讨论的相同特性。

列摘要部分指示了预测数据框中的三列。它们如下列出：

• 预测：此列是枚举类型，表示预测数据框中输入行的预测值。

• P0：此列表示预测值为 0 的概率。

• P1：此列表示预测值为 1 的概率。

让我们查看数据以更好地理解其内容。你可以通过点击预测数据框输出中的操作部分的查看数据按钮来查看数据框的内容，如图 2.44 所示。

以下截图显示了查看预测数据时的预期输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_045.jpg

图 2.45 – 预测数据框的内容

让我们回到预测输出的预测子部分，如图 2.43 所示。让我们将预测结果与用作预测输入的数据框合并。你可以通过点击将预测与框架合并按钮来完成此操作。

以下截图显示了该操作的输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_046.jpg

图 2.46 – 将预测与框架合并的结果

点击查看框架按钮会显示合并框架，它也是一个数据框。让我们点击查看框架按钮来查看框架的内容。

以下截图显示了从框架合并输出中的查看框架操作的输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_047.jpg

图 2.47 – 用于预测的数据框与预测结果的合并

在合并预测输出的操作部分的查看数据按钮中选择，会显示包含预测值的完整数据框内容。

以下截图显示了合并数据框的内容：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_02_048.jpg

图 2.48 – 合并数据框的内容

观察合并数据框的内容，你会注意到你现在可以轻松地比较预测值，如预测列中提到的，以及与同一行中的HeartDisease列的实际值进行比较。

恭喜！你已经正式对一个你训练的模型进行了预测，并将结果合并到一个单独的数据框中，以便进行比较查看，你可以与你的利益相关者分享。因此，这总结了我们的 H2O Flow 创建 ML 管道的教程。

摘要

在本章中，我们了解了 H2O Flow 提供的各种功能。在熟悉了 Web UI 之后，我们开始实现我们的机器学习流程。我们导入了并解析了心力衰竭预测数据集。我们了解了可以在数据框上执行的各种操作，了解了数据框的元数据和统计数据，并为后续的训练、验证和预测模型做好了准备。

然后，我们使用 AutoML 在数据框上训练模型。我们了解了需要输入的各种参数，以正确配置 AutoML。我们使用 AutoML 训练模型并理解了排行榜。然后，我们更深入地研究了训练模型的细节，并尽力理解它们的特征。

在我们的模型训练完成后，我们对它进行了预测，并通过将其与原始数据框结合来探索预测输出，以便我们可以比较预测值。

在下一章中，我们将进一步探索各种数据操作操作。这将帮助我们了解在数据清洗和转换数据框方面需要采取哪些步骤，以及它如何提高训练模型的品质。

第二部分 H2O AutoML 深入探讨

本部分将帮助您理解 H2O AutoML 的内部工作原理。这包括 H2O AutoML 如何处理数据处理、训练和模型选择，以及它是如何衡量训练模型性能的。本部分还将帮助您理解如何阅读各种性能图表和其他模型细节，这些细节将有助于理解模型的行为。所有这些都将帮助您进一步实验和探索 H2O AutoML，并根据您的需求最大限度地利用它。

本节包括以下章节：

• 第三章，理解数据处理

• 第四章，理解 H2O AutoML 训练和架构

• 第五章，理解 AutoML 算法

• 第六章，理解 H2O AutoML 排行榜和其他性能指标

• 第七章，与模型可解释性工作

第三章：理解数据处理

机器学习（ML）模型是在数据拟合到 ML 算法后得到的输出。它代表了各种特征之间的潜在关系以及这种关系如何影响目标变量。这种关系完全取决于数据集的内容。尽管使用相同的 ML 算法，但每个 ML 模型都是独特的，这是因为用于训练该模型的特定数据集。数据可以从各种来源收集，并且可以具有不同的模式和结构，它们之间可能不需要结构上兼容，但实际上可能相互关联。这种关系可能非常有价值，也可能潜在地成为好模型和坏模型之间的区别。因此，将数据转换为满足 ML 算法的要求，最终训练出一个好模型是很重要的。

数据处理、数据准备和数据预处理都是 ML 管道中的步骤，它们通过转换数据结构来最佳地暴露特征之间的潜在关系。数据处理可能是 ML 管道中最具挑战性的步骤，因为转换过程没有固定的步骤。数据处理完全取决于您希望解决的问题；然而，所有数据集之间都有一些相似之处，这可以帮助我们定义可以执行以优化 ML 管道的某些过程。

在本章中，我们将了解一些在数据处理中经常使用的常见功能，以及 H2O 内置的操作如何帮助我们轻松地执行它们。我们将了解一些可以重构我们数据框结构的 H2O 操作。我们将了解如何处理缺失值以及值插补的重要性。然后，我们将研究如何操作数据框中的各种特征列，以及如何根据不同的需求切片数据框。我们还将研究编码是什么以及不同的编码类型。

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

• 重构你的数据框

• 处理数据框中的缺失值

• 操作数据框的特征列

• 文本数据的分词

• 使用目标编码对数据进行编码

技术要求

本章中的所有代码示例都是在Jupyter Notebook上运行的，以便于理解代码块中每一行的操作。您可以通过 Python 或 R 脚本执行器运行整个代码块并观察输出结果，或者您可以通过安装 Jupyter Notebook 并观察代码块中每一行的执行结果来跟随操作。

要安装 Jupyter Notebook，请确保您的系统上安装了最新版本的 Python 和pip，并执行以下命令：

pip install jupyterlab

一旦 JupyterLab 成功安装，您可以通过在终端执行以下命令来在本地启动 Jupyter Notebook：

jupyter notebook

这将在你的默认浏览器上打开 Jupyter Notebook 页面。然后你可以选择你想要使用的语言并开始逐步执行代码步骤。

本章的所有代码示例都可以在 GitHub 上找到，网址为 github.com/PacktPublishing/Practical-Automated-Machine-Learning-on-H2O/tree/main/Chapter%203。

现在，让我们通过首先创建一个 dataframe 并将其重新格式化以满足我们的模型训练要求来开始处理我们的数据。

重新格式化你的 dataframe

从各种来源收集的数据通常被称为 原始数据。它被称为原始数据，是因为其中可能包含很多不必要的或过时的数据，这些数据可能不会必然有利于我们的模型训练。收集到的数据结构也可能在所有来源之间不一致。因此，首先将来自各种来源的数据重新格式化为一致格式变得非常重要。

你可能已经注意到，一旦我们将数据集导入 H2O，H2O 会将数据集转换为 .hex 文件，也称为 dataframe。你也可以选择导入多个数据集。假设你正在从各种来源导入多个数据集，每个数据集都有自己的格式和结构，那么你需要一个特定的功能来帮助你重新格式化数据集的内容并将它们合并成一个可以输入到你的机器学习流程中的单个 dataframe。

H2O 提供了几个你可以用来执行所需操作的功能。

这里有一些 dataframe 操作功能，可以帮助你重新格式化你的 dataframe：

• 将两个数据框的列合并

• 将两个数据框的行合并

• 合并两个数据框

让我们看看如何在 H2O 中将来自不同 dataframe 的列合并。

将两个数据框的列合并

最常见的 dataframe 操作功能之一是从不同的 dataframe 中合并不同的列。有时，一个 dataframe 的列可能与另一个 dataframe 的列相关。这在模型训练期间可能是有益的。因此，拥有一个可以帮助我们操作这些列并将它们合并成一个用于模型训练的单个 dataframe 的功能是非常有用的。

H2O 有一个名为 cbind() 的函数，可以将一个数据集的列合并到另一个数据集中。

让我们在我们的 Jupyter Notebook 中使用 Python 尝试这个函数。按顺序执行以下步骤：

1. 导入 h2o 库：

   import h2o
   

2. 导入 numpy 库；我们将使用它来创建一个用于我们研究的样本 dataframe：

   import numpy as np
   

3. 初始化 h2o 服务器：

   h2o.init()
   

4. 现在，让我们创建一个名为 important_dataframe_1 的数据框；这是一个列很重要的数据框。为了确保你在数据集中生成的值与这个例子中的相同，将 numpy 的随机种子值设置为 123。我们将设置行数为 15，列数为 5。你可以给列取任何你喜欢的名字：

   np.random.seed(123)
   important_dataframe_1 = h2o.H2OFrame.from_python(np.random.randn(15,5).tolist(), column_names=list([" important_column_1" , " important_column_2" , " important_column_3" , " important_column_4" , " important_column_5" ]))
   

5. 让我们通过执行以下代码来查看数据集的内容：

   important_dataframe_1.describe
   

以下截图显示了数据集的内容：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_001.jpg

图 3.1 – important_dataframe_1 数据内容

1. 让我们创建另一个名为important_dataframe_2的数据框，就像之前一样，但具有不同的列名，但行数相等，只有2列：

   important_dataframe_2 = h2o.H2OFrame.from_python(np.random.randn(15,2).tolist(), column_names=list([" important_column_6" , " important_column_7" ]))
   

2. 让我们查看这个数据框的内容：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_002.jpg

图 3.2 – important_dataframe_2 数据内容

1. 现在，让我们使用cbind()函数将两个数据框的列合并，并将它们存储在另一个名为final_dataframe的变量中：

   final_dataframe = important_dataframe_1.cbind(important_dataframe_2)
   

2. 现在，让我们观察final_dataframe：

   final_dataframe.describe
   

你应该看到final_dataframe的内容如下：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_003.jpg

图 3.3 – cbind()后的 final_dataframe 数据内容

在这里，你会注意到我们已经成功地将important_dataframe_2的列与important_dataframe_1的列合并在一起。

这就是如何使用cbind()函数将两个不同数据集的列合并成一个单一的数据框。在使用cbind()函数时需要注意的唯一一点是，要确保要合并的两个数据集具有相同数量的行。此外，如果你有具有相同列名的数据框，那么 H2O 将在数据框的列名前添加一个0。

现在我们已经知道了如何合并不同数据框的列，让我们看看如何将具有相同列结构的多数据框的列值合并在一起。

合并两个数据框的行

大多数大型企业通常处理大量的数据。这些数据通常被分成多个块，以便更快、更有效地存储和读取。然而，在模型训练期间，我们经常需要访问所有这些分区的数据集。这些数据集具有相同的结构，但数据内容是分布的。换句话说，数据框具有相同的列；然而，数据值或行被分散在它们之间。我们经常需要一个函数将所有这些数据框合并在一起，以便我们有所有数据值可用于模型训练。

H2O 有一个名为rbind()的函数，可以将一个数据集的行合并到另一个数据集中。

让我们在以下示例中尝试这个函数：

1. 导入h2o库：

   import h2o
   

2. 导入numpy库；我们将使用它来创建用于我们研究的随机数据框：

   import numpy as np
   

3. 初始化h2o服务器：

   h2o.init()
   

4. 现在，让我们创建一个名为important_dataframe_1的随机数据框。为了确保你在数据集中生成与这个例子相同的值，将numpy的随机种子值设置为123。我们将设置行数为15，列数为5。你可以给列取任何你喜欢的名字：

   np.random.seed(123)
   important_dataframe_1 = h2o.H2OFrame.from_python(np.random.randn(15,5).tolist(), column_names=list([" important_column_1" , " important_column_2" ," important_column_3" ," important_column_4" ," important_column_5" ]))
   

5. 让我们查看数据框的行数，它应该是15：

   important_dataframe_1.nrows
   

6. 让我们创建另一个名为important_dataframe_2的数据框，就像之前的一个一样，具有相同的列名和任意数量的行。在示例中，我使用了10行：

   important_dataframe_2 = h2o.H2OFrame.from_python(np.random.randn(10,5).tolist(), column_names=list([" important_column_1" , " important_column_2" ," important_column_3" ," important_column_4" ," important_column_5" ]))
   

7. 让我们查看important_dataframe_2的行数，它应该是10：

   important_dataframe_2.nrows
   

8. 现在，让我们使用rbind()函数将两个数据框的行合并并存储在另一个名为final_dataframe的变量中：

   final_dataframe = important_dataframe_1.rbind(important_dataframe_2)
   

9. 现在，让我们观察final_dataframe：

   final_dataframe.describe
   

你应该看到final_dataframe的内容如下：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_004.jpg

图 3.4 – 使用 rbind()后的 final_dataframe 数据内容

1. 让我们查看final_dataframe的行数：

   final_dataframe.nrows
   

最后一个操作的输出应该显示最终数据集的行数。你会看到值是25，数据框的内容是前两个数据集的合并行值。

现在我们已经了解了如何在 H2O 中使用rbind()函数合并两个数据框的行，让我们看看我们如何完全合并两个数据集。

合并两个数据框

你可以直接合并两个数据框，将它们的行和列合并成一个数据框。H2O 提供了一个merge()函数，用于合并具有公共列或公共列的两个数据集。在合并过程中，两个数据集共有的列用作合并键。如果它们只有一个公共列，那么这个列形成合并的单个主键。如果有多个公共列，那么 H2O 将根据这些列的数据值形成所有这些列的复杂键，并将其用作合并键。如果两个数据集之间有多个公共列，而你只想合并特定的子集，那么你需要重命名其他公共列以消除相应的公共性。

让我们在下面的 Python 示例中尝试这个函数：

1. 导入h2o库：

   import h2o
   

2. 导入numpy库；我们将使用它来创建一个用于我们研究的随机数据框：

   import numpy as np
   

3. 初始化h2o服务器：

   h2o.init()
   

4. 现在，让我们创建一个名为dataframe_1的数据框。该数据框有3列：words、numerical_representation和letters。现在，让我们按照以下内容填写数据内容：

   dataframe_1 = h2o.H2OFrame.from_python({'words':['Hello', 'World', 'Welcome', 'To', 'Machine', 'Learning'], 'numerical_representation': [0,1,2,3,4,5],'letters':['a','b','c','d']})
   

5. 让我们查看数据集的内容：

   dataframe_1.describe
   

6. 你将注意到数据集的内容如下：https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_005.jpg

图 3.5 – dataframe_1 数据内容

1. 让我们创建另一个名为dataframe_2的数据框。这个数据框也包含3列：numerical_representation列、letters列（这两个列与dataframe_1相同），以及一个不常见的列。让我们称它为other_words：

   dataframe_2 = h2o.H2OFrame.from_python({'other_words':['How', 'Are', 'You', 'Doing', 'Today', 'My', 'Friend', 'Learning', 'H2O', 'Artificial', 'Intelligence'], 'numerical_representation': [0,1,2,3,4,5,6,7,8,9],'letters':['a','b','c','d','e']})
   

2. 让我们查看这个数据框的内容：

   dataframe_2.head(11)
   

执行代码后，你应该在你的笔记本中看到以下输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_006.jpg

图 3.6 – dataframe_2 数据内容

1. 现在，让我们使用 merge() 操作将 dataframe_1 合并到 dataframe_2 中：

   final_dataframe = dataframe_2.merge(dataframe_1)
   

2. 让我们现在观察 final_dataframe：

   final_dataframe.describe
   

3. 你应该看到 final_dataframe 的内容如下：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_007.jpg

图 3.7 – merge() 后的 final_dataframe 内容

你会注意到 H2O 使用了 numerical_representation 列与其他列中适当的值的组合。

现在，你可能想知道为什么没有 4 这一行的数据。那是因为在合并过程中，我们有两个共同的列：numerical_representation 和 letters。所以，H2O 使用了一个复杂的合并键，它同时使用了这两个列：（0，a）、（1，b）、（2，c），以此类推。

现在你可能有的下一个问题是 关于值 5 的那一行，它在 letters 列中没有值。 那是因为在机器学习中，即使是空值也被视为一个独特的值。因此，在合并过程中，生成的复杂键将 （5，） 视为一个有效的合并键。

H2O 丢弃了所有剩余的值，因为 dataframe_1 没有更多的数值表示值。

1. 你可以通过将 all_x 参数设置为 True 来强制 H2O 不丢弃合并键列中的任何值，如下所示：

   final_dataframe = dataframe_2.merge(dataframe_1, all_x = True)
   

2. 现在，让我们观察 describe 属性的内容：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_008.jpg

图 3.8 – 强制 merge() 后的 final_dataframe 数据内容

你会注意到我们现在将两个 dataframe 的所有值合并到一个单一的 dataframe 中。我们有了从 0 到 9 的所有数值表示，以及从 dataframe_2 中缺失的 a 到 e 的所有字母，以及来自 other_words 列和 words 列的正确值。

回顾一下，我们学习了如何合并 dataframe 的列和行。我们还学习了如何使用 merge() 函数将整个 dataframe 合并在一起。然而，我们注意到，即使数据框的关键列中没有共同的数据值，我们强制合并数据框时，最终在 dataframe 中出现了缺失值。

现在，让我们看看我们可以使用哪些不同的方法来处理 H2O 中的缺失值。

处理 dataframe 中的缺失值

在实际世界中，数据集中的缺失值是最常见的问题。通常，在从各种来源收集的大量数据块中，至少会有几个缺失数据的实例。数据可能因为多种原因而缺失，从数据在源头未生成到数据收集器的停机等。处理缺失数据对于模型训练非常重要，因为许多机器学习算法不支持缺失数据。那些支持缺失数据的算法可能会更重视寻找缺失数据中的模式，而不是实际存在的数据，这会分散机器学习的注意力。

缺失数据通常被称为不可用（NA）或nan。在我们可以将数据框发送给模型训练之前，我们需要首先处理这些类型的值。您可以选择删除包含任何缺失值的整个行，或者用默认值填充这些值，这些默认值可以是该数据列的默认值或常见值。您如何处理缺失值完全取决于哪些数据缺失以及这对于整体模型训练的重要性。

H2O 提供了一些功能，您可以使用这些功能来处理数据框中的缺失值。以下是一些例子：

• fillna()函数

• 在框架中替换值

• 估算

接下来，让我们看看如何使用 H2O 在数据框中填充缺失值。

填充 NA 值

fillna()是 H2O 中的一个函数，您可以使用它以顺序方式填充缺失数据值。如果您有一个列中的某些数据值是按顺序排列的，例如时间序列或任何按顺序增加或减少的度量，并且可以排序，那么这个功能特别有用。序列中值的差异越小，这个函数就越适用。

fillna()函数有以下参数：

• method：这可以是前向或后向。它表示 H2O 在数据框中开始填充 NA 值的方向。

• axis：0表示按列填充，1表示按行填充。

• maxlen：要填充的最大连续 NA 值数。

让我们通过 Python 的例子来看看我们如何使用这个函数来填充缺失值：

1. 导入h2o库：

   import h2o
   

2. 导入numpy库；我们将使用它来创建用于我们研究的随机数据框：

   import numpy as np
   

3. 初始化h2o服务器：

   h2o.init()
   

4. 创建一个包含1000行、3列和一些 NA 值的随机数据框：

   dataframe = h2o.create_frame(rows=1000, cols=3, integer_fraction=1.0, integer_range=100, missing_fraction=0.2, seed=123)
   

5. 让我们观察这个数据框的内容。执行以下代码，您将在数据框中看到某些缺失值：

   dataframe.describe
   

您应该看到数据框的内容如下：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_009.jpg

图 3.9 – 数据框内容

1. 现在我们使用fillna()函数来前向填充 NA 值。执行以下代码：

   filled_dataframe = dataframe.fillna(method=" forward" , axis=0, maxlen=1)
   

2. 让我们观察填充后的数据框内容。执行以下代码：

   filled_dataframe.describe
   

3. 您应该看到数据框的内容如下：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_010.jpg

图 3.10 – 填充后的数据框内容

fillna()函数已按顺序填充数据框中的大多数 NA 值。

然而，你会注意到我们仍然有一些NA。由于这是第一列，H2O 在记录中没有先前的值来填充它，因此它跳过了它。

现在我们已经了解了如何使用 H2O 中的fillna()函数按顺序在数据框中填充数据，让我们看看我们如何替换数据框中的某些值。

替换数据框中的值

数据处理中经常需要的一种常见功能是替换数据框中的某些值。你可能想这样做的原因有很多。这在数值数据中尤为常见，其中一些最常用的转换包括舍入值、规范化数值范围或只是纠正数据值。在本节中，我们将探讨我们可以在 H2O 中使用的一些函数来替换数据框中的值。

让我们首先创建一个我们可以用来测试这些函数的数据框。执行以下代码，以便我们有一个可以操作的数据框：

import h2o
h2o.init()
dataframe = h2o.create_frame(rows=10, cols=3, real_range=100, integer_fraction=1, missing_fraction=0.1, seed=5)
dataframe.describe

数据框应该看起来如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_011.jpg

图 3.11 – 数据框数据内容

因此，我们有一个包含三个列：C1、C2和C3的数据框。每个列都有几个负数和一些nan值。让我们看看我们如何处理这个数据框。

让我们从简单的事情开始。让我们更新单个数据值，也称为99。你可以根据其在数据框中的位置更新单个数据值的值，如下所示：

dataframe[3,1] = 99

注意，数据框中的列和行都从0开始。因此，我们将行号为3、列号为1的值设置为99。你可以通过执行以下dataframe.describe来在数据框中看到结果：

dataframe.describe

数据框应该看起来如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_012.jpg

图 3.12 – 数据更新后的数据框内容

正如你在数据框中看到的，我们将之前位于C2列第三行的nan值替换为99。

这只是一个数据值的操作。让我们看看我们如何替换整个列的值。让我们将C3列的数据值增加到原始值的 3 倍。你可以通过执行以下代码来实现：

dataframe[2] = 3*dataframe[2]

你可以通过执行以下dataframe.describe来在数据框中看到结果：

dataframe.describe

数据框应该看起来如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_013.jpg

图 3.13 – 列值更新后的数据框内容

我们可以在输出中看到，C3列的值现在已增加到原始列值的 3 倍。

我们到目前为止所执行的所有替换都是直接的。让我们尝试在数据框上进行一些条件更新。让我们将数据框中的所有负数四舍五入到0。所以，条件是我们只更新负数为0，不更改任何正数。您可以进行如下条件更新：

dataframe[dataframe['C1'] < 0, " C1" ] = 0
dataframe[dataframe['C2'] < 0, " C2" ] = 0
dataframe[dataframe['C2'] < 0, " C3" ] = 0

您可以通过执行以下dataframe.describe来在数据框中看到结果：

dataframe.describe

数据框应如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_014.jpg

图 3.14 – 条件更新后的数据框内容

如您在数据框中所见，所有负值都已向上舍入/替换为0。

现在，如果我们不想将负数向上舍入到0，而是希望仅反转负数，我们可以通过结合条件更新和算术更新来实现。请参考以下示例：

dataframe[" C1" ] = (dataframe[" C1" ] < 0).ifelse(-1*dataframe[" C1" ], dataframe[" C1" ])
dataframe[" C2" ] = (dataframe[" C2" ] < 0).ifelse(-1*dataframe[" C2" ], dataframe[" C2" ])
dataframe[" C3" ] = (dataframe[" C3" ] < 0).ifelse(-1*dataframe[" C3" ], dataframe[" C3" ])

现在，让我们尝试看看我们是否可以替换剩余的fillna()函数，但如果nan值只是某些缺失值，这些值并不完全符合任何递增或递减模式，而我们只想将其设置为 0 怎么办？让我们现在就做。运行以下代码：

dataframe[dataframe[" C1" ].isna(), " C1" ] = 0
dataframe[dataframe[" C2" ].isna(), " C2" ] = 0
dataframe[dataframe[" C3" ].isna(), " C3" ] = 0

您可以通过执行以下dataframe.describe来在数据框中看到结果：

dataframe.describe

数据框应如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_015.jpg

图 3.15 – 替换 nan 值为 0 后的数据框内容

isna()函数是一个检查数据中的值是否为nan的函数，并返回True或False。我们使用这个条件来替换数据框中的值。

提示

在数据框中操作和替换值有多种方法，H2O 提供了丰富的功能来简化实现。请随意探索和实验更多关于操作数据框中的值。您可以在以下链接中找到更多详细信息：docs.h2o.ai/h2o/latest-stable/h2o-py/docs/frame.xhtml。

现在我们已经学习了在数据框中替换值的各种方法，让我们看看数据科学家和工程师经常采用的一种更高级的方法。

补充

之前，我们看到了如何使用fillna()函数在数据集中替换 nan 值，该函数按顺序替换 dataframe 中的 nan 数据。fillna()函数以顺序方式填充数据；然而，数据不一定总是具有顺序性。例如，考虑一个关于购买游戏笔记本电脑的人的数据集。该数据集将主要包含 13-28 岁年龄段的关于人的数据，还有一些异常值。在这种情况下，如果fillna()函数中有任何 nan 值用于填充 nan 值，那么任何异常值之后的任何 nan 值都会在 dataframe 中引入偏差。我们需要用一个在产品年龄组的标准分布中常见的值来替换 nan 值，这个值在 13 和 28 之间，而不是像 59 这样的值，因为 59 出现的可能性较小。

假设是替换 dataframe 中某些值的过程，用适当的替代值替换，这些替代值不会引入任何可能影响模型训练的偏差或异常值。用于计算替代值的计算方法被称为假设策略。假设是数据处理中最重要的一种方法，它处理缺失和 nan 值，并试图用可能对模型训练过程引入最少偏差的值来替换它们。

H2O 有一个名为impute()的函数，专门提供此功能。它有以下参数：

• column: 此参数接受要设置impute()列号的列。值1假设整个 dataframe。

• method: 此参数设置要使用的假设方法。方法可以是mean、median或mode。

• combine_method: 此参数指定当选择median作为假设方法时，如何组合偶数样本的量数。组合方法可以是interpolate、average、low或high。

• group_by_frame: 此参数假设所选预计算的分组框架的值。

• by: 此参数按所选列对假设结果进行分组。

• values: 此参数接受一个列表，其中包含每列的值。列表中的None值会跳过该列。

让我们通过一个 Python 示例来看看我们如何使用此函数来填充缺失值。

对于这个，我们将使用高中学生短跑数据集。高中学生短跑数据集是一个包含高中学生年龄、体重、最大记录速度和 100 米短跑表现的记录数据集。该数据集用于预测年龄、体重和短跑速度如何影响学生在 100 米短跑比赛中的表现。

数据集看起来如下：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_016.jpg

图 3.16 – 一位高中学生的短跑数据集

数据集的特征如下：

• 年龄：学生的年龄

• 体重：学生的体重（千克）

• max_speed：学生每小时的最大冲刺速度（千米/小时）

• 100_meter_time：学生完成 100 米冲刺所需的时间（秒）

如你所见，100_meter_time列中有很多缺失值。

我们不能简单地使用fillna()函数，因为这会在缺失值恰好发生在最快或最慢时间之后时引入数据偏差。我们也不能简单地用常数替换这些值。

实际上，替换这些缺失值，用平均青少年 100 米冲刺的正常值来替换是有意义的。我们已经有大多数学生的数据，所以我们可以使用他们的结果来计算一个一般的 100 米冲刺平均时间，并以此作为基准来替换所有缺失值，而不会引入任何偏差。

这正是填充缺失值所用的。让我们使用填充函数来填充这些缺失值：

1. 导入h20模块并启动h20服务器：

   import h2o
   h2o.init()
   

2. 我们然后使用h2o.import_file()导入高中学生冲刺数据集：

   dataframe = h2o.import_file(" Dataset/high_school_student_sprint.csv" )
   

3. 使用impute()函数，让我们通过mean来填充100_meter_time列中的缺失值，并显示数据：

   dataframe.impute(" 100_meter_time" , method = " mean" )
   dataframe.describe
   

你将看到以下填充后的数据框输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_017.jpg

图 3.17 – 使用平均值填充的 100 米时间列

1. H2O 计算了100_meter_time列所有值的平均值为23.5558，并用它替换了缺失值。

类似地，你还可以使用median值来代替mean。然而，请注意，如果某一列包含分类值，那么方法必须是mode。这个决定取决于你，根据最有助于替换缺失值的 dataset：

dataframe.impute(" 100_meter_time" , method = " median" )
dataframe.impute(" 100_meter_time" , method = " mode" )

1. 让我们稍微增加一下复杂性。如果平均 100 米冲刺时间在所有学生之间并不真正可比，会怎样？如果按年龄比较，表现会更相似呢？例如，16 岁的学生比 13 岁的学生跑得快，因为他们身体发育得更成熟。在这种情况下，在填充 16 岁学生的缺失值时考虑 13 岁学生的冲刺时间就没有意义了。这就是我们可以使用impute()函数的group参数的地方：

   dataframe = h2o.import_file(" Dataset/high_school_student_sprint.csv" )
   dataframe.impute(" 100_meter_time" , method = " mean" , by=[" age" ])
   dataframe.describe
   

你将看到以下输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_018.jpg

图 3.18 – 使用其平均值填充的 100 米冲刺数据，并按年龄分组

你会注意到现在 H2O 已经按年龄计算了平均值，并用它替换了相应年龄的mean值，在所有impute()函数中灵活地填充正确的值。

impute()函数在填充数据框中的正确值方面非常强大。通过列以及框架进行分组的附加参数使其在处理各种缺失值时非常灵活。

随意使用和探索这些函数在不同的数据集上。最终，所有这些函数都是数据科学家和工程师用来提高数据质量的工具；真正的技能是理解何时以及如何使用这些工具从您的数据中获得最大收益，这需要实验和实践。

现在我们已经了解了我们可以用不同的方式处理缺失数据，让我们继续到数据处理过程的下一部分，即如何操纵 dataframe 的特征列。

操纵 dataframe 的特征列

在大多数情况下，您数据处理活动将主要涉及操纵数据框的列。最重要的是，列中的值类型和列中值的顺序将在模型训练中发挥重要作用。

H2O 提供了一些功能，可以帮助您做到这一点。以下是一些帮助您处理 dataframe 中缺失值的功能：

• 列排序

• 改变列的类型

让我们首先了解如何使用 H2O 对列进行排序。

列排序

理想情况下，您希望在将数据传递给模型训练之前对 dataframe 中的数据进行洗牌。然而，可能存在某些场景，您可能希望根据列中的值重新排序 dataframe。

H2O 有一个名为 sort() 的功能，可以根据列中的值对 dataframe 进行排序。它有以下参数：

• by：要排序的列。您也可以通过列表传递多个列名。

• ascending：一个表示 H2O 应该按什么方向排序列的布尔数组。如果为 True，则 H2O 将按升序排序该列。如果为 False，则 H2O 将按降序排序。如果没有传递任何标志，则 H2O 默认按升序排序。

H2O 将如何排序 dataframe 取决于是否将单个列名传递给 sort() 函数或多个列名。如果只传递单个列名，则 H2O 将返回一个按该列排序的框架。

然而，如果传递了多个列，则 H2O 将返回一个按以下方式排序的数据框：

• H2O 首先将对传递给参数的第一个列对 dataframe 进行排序。

• H2O 将根据传递给参数的下一列对 dataframe 进行排序，但只有与第一排序列中相同的值的行才会被排序。如果前几列中没有重复值，则不会对后续列进行排序。

让我们通过一个 Python 示例来看看我们如何使用此函数来排序列：

1. 导入 h2o 库并初始化它：

   import h2o
   h2o.init()
   

2. 执行以下代码创建一个 dataframe 并观察数据集：

   dataframe = h2o.H2OFrame.from_python({'C1': [3,3,3,0,12,13,1,8,8,14,15,2,3,8,8],'C2':[1,5,3,6,8,6,8,7,6,5,1,2,3,6,6],'C3':[15,14,13,12,11,10,9,8,7,6,5,4,3,2,1]})
   dataframe.describe
   

数据集的内容应如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_019.jpg

图 3.19 – dataframe_1 数据内容

1. 因此，目前，列sort()函数中的值被放入by参数中，表示数据框的第一列，或者通过传递**[‘C1’]**，这是一个包含列名的列表，按顺序对数据集进行排序：

   sorted_dataframe_1 = dataframe.sort(0)
   sorted_dataframe_1.describe
   

你应该得到以下代码的输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_020.jpg

图 3.20 – 按 C1 列排序的 dataframe_1

你会发现数据框现在已按C1列的升序排序。

1. 让我们看看如果我们通过by参数传递多个列来按多个列排序，我们会得到什么。运行以下代码行：

   sorted_dataframe_2 = dataframe.sort(['C1','C2']) sorted_dataframe_2.describe
   

你应该得到以下输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_021.jpg

图 3.21 – 按列 C1 和 C2 排序的 dataframe_1

如你所见，H2O 首先使用sort函数对列进行排序。

1. 你也可以通过在ascending参数中传递False来反转排序顺序。让我们通过运行以下代码行来测试一下：

   sorted_dataframe_3 = dataframe.sort(by=['C1','C2'], ascending=[True,False])
   sorted_dataframe_3.describe
   

你应该看到以下输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_022.jpg

图 3.22 – dataframe_1 按 C1 列升序排序，按 C2 列降序排序

在这种情况下，H2O 首先按C1列对列进行排序。然后，对于在C1列中具有相同值的行，它按C2列对这些行进行排序。然而，这次它是按降序排序的。

现在你已经学会了如何按单列以及多列对数据框进行排序，让我们继续学习另一个更改列类型的列操作函数。

更改列类型

正如我们在第二章中看到的，使用 H2O Flow (H2O 的 Web UI)，我们将Heart Disease列的类型从numerical更改为enum。我们这样做的原因是列的类型在模型训练中起着重要作用。在模型训练期间，列的类型决定了 ML 问题是分类问题还是回归问题。尽管这两种情况中的数据本质上都是数值的，但 ML 算法如何处理该列完全取决于其类型。因此，在数据收集的初始阶段可能未正确设置列类型时，正确设置列类型变得非常重要。

H2O 有几个函数不仅可以帮助你更改列的类型，还可以对列类型进行初始检查。

其中一些函数如下：

• .isnumeric(): 检查数据框中的列是否为数值类型。相应地返回True或False

• .asnumeric(): 为指定列创建一个新框架，其中所有值都转换为数值

• .isfactor(): 检查数据框中的列是否为分类类型。相应地返回True或False

• .asfactor(): 为指定列创建一个新框架，其中所有值都转换为分类类型

• .isstring(): 检查数据框中的列是否为字符串类型。相应地返回True或False

• .ascharacter(): 为指定列创建一个新框架，其中所有值都转换为字符串类型

让我们看看如何在 Python 中使用这些函数来更改列类型的一个例子：

1. 导入h2o库并初始化 H2O：

   import h2o
   h2o.init()
   

2. 执行以下代码行创建一个数据框并观察数据集：

   dataframe = h2o.H2OFrame.from_python({'C1': [3,3,3,0,12,13,1,8,8,14,15,2,3,8,8],'C2':[1,5,3,6,8,6,8,7,6,5,1,2,3,6,6],'C3':[15,14,13,12,11,10,9,8,7,6,5,4,3,2,1]})
   dataframe.describe
   

数据集的内容应该是这样的：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_023.jpg

图 3.23 – 数据框数据内容

1. 让我们通过使用isnumeric()函数来确认numerical列如下：

   dataframe['C1'].isnumeric()
   

你应该得到一个True的输出。

1. 让我们看看如果我们使用asfactor()函数检查categorical列会得到什么：

   dataframe['C1'].isfactor()
   

你应该得到一个False的输出。

1. 现在，让我们使用asfactor()函数将categorical列转换为因子类型，然后检查isfactor()是否返回True：

   dataframe['C1'] = dataframe['C1'].asfactor()
   dataframe['C1'].isfactor()
   

你现在应该得到一个True的输出。

1. 你可以使用asnumeric()函数将numerical列转换为数值类型：

   dataframe['C1'] = dataframe['C1'].asnumeric()
   dataframe['C1'].isnumeric()
   

你现在应该得到一个True的输出。

现在你已经学会了如何对数据框的列进行排序和更改列类型，让我们继续学习数据处理中的另一个重要主题，即分词和编码。

文本数据的分词

并非所有机器学习算法（MLAs）都专注于数学问题解决。自然语言处理（NLP）是机器学习的一个分支，它专门分析从文本数据中提取的意义，尽管它也会尝试从文档或任何文本中提取意义和理解内容。训练 NLP 模型可能非常棘手，因为每种语言都有其自己的语法规则，某些单词的解释在很大程度上依赖于上下文。尽管如此，NLP 算法通常会尽力训练一个可以预测文本文档的意义和情感的模型。

训练 NLP 算法的方法是首先将文本数据块分解成更小的单元，称为标记。标记可以是单词、字符，甚至是字母。这取决于 MLA 的要求以及它是如何使用这些标记来训练模型的。

H2O 有一个名为tokenize()的函数，它可以帮助将数据框中的字符串数据分解成标记，并为进一步处理创建一个包含所有标记的单独列。

它有以下参数：split：我们在该参数中传递一个正则表达式，该表达式将由函数用于将文本数据分割成标记。

让我们看看如何使用这个函数在数据框中对字符串数据进行分词的例子：

1. 导入h2o库并初始化它：

   import h2o
   h2o.init()
   

2. 执行以下代码行创建一个数据框并观察数据集：

   dataframe1 = h2o.H2OFrame.from_python({'C1':['Today we learn AI', 'Tomorrow AI learns us', 'Today and Tomorrow are same', 'Us and AI are same']})
   dataframe1 = dataframe1.ascharacter()
   dataframe1.describe
   

数据集应该看起来如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_024.jpg

图 3.24 – 数据框数据内容

这种类型的文本数据通常在生成大量日志文本或对话数据的系统中收集。为了解决这类自然语言处理任务，我们需要将句子分解成单个标记，以便我们最终可以构建这些文本的上下文和意义，这将有助于机器学习算法进行语义预测。然而，在深入研究自然语言处理的复杂性之前，数据科学家和工程师将首先通过分词来处理这些数据。

1. 让我们使用这个函数来分词我们的数据框，观察分词后的列：

   tokenized_dataframe = dataframe1.tokenize("  " )
   tokenized_dataframe
   

你应该看到以下数据框：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_025.jpg

图 3.25 – 分词后的数据框内容

你会注意到tokenize()函数将文本数据分割成标记，并将标记作为行附加到单个列中。你还会注意到所有分词后的句子都由空行分隔。你可以通过使用nrows比较数据框中所有句子的单词数量以及句子之间的空格与分词数据集的行数来交叉检查这一点。

这些是在将数据输入到机器学习管道进行训练之前用于处理数据的常用数据处理方法。还有许多方法和技巧可以用来进一步清理和抛光数据框。如此之多，以至于你可以专门写一本书来讨论它们。数据处理恰好是整个机器学习生命周期中最困难的部分。用于训练的数据质量取决于问题陈述的上下文。它还取决于数据科学家和工程师在处理数据时的创造力和独创性。数据处理的目标是从数据集中提取尽可能多的信息，并从数据中去除噪声和偏差，以便在训练期间进行更有效的数据分析。

使用目标编码进行数据编码

正如我们所知，机器只能理解数字。然而，许多现实世界的机器学习问题都围绕着非数字性质的对象和信息。例如，状态、名称和类别等通常被表示为类别而不是数字。这种数据被称为分类数据。分类数据在分析和预测中通常会扮演重要角色。因此，有必要将这些分类值转换为数值格式，以便机器能够理解它们。这种转换还应该以这种方式进行，即我们不会失去这些类别的固有含义，也不会向数据中引入新的信息，例如数字的增量性质等。

这就是编码被使用的地方。编码是一个过程，其中分类值被转换，换句话说，编码为数值。有许多编码方法可以执行这种转换。其中最常用的一种是目标编码。

目标编码是一种编码过程，通过计算给定类别中目标变量发生的平均概率，将分类值转换为数值。H2O 也有帮助用户在数据上实现目标编码的方法。

为了更好地理解这种方法，考虑以下示例神话生物数据集：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_026.jpg

图 3.26 – 我们的神话生物数据集

此数据集包含以下内容：

• 动物：此列包含动物名称的分类值。

• 神话：此列包含0的二进制值和1的二进制值。1表示生物是神话中的，而0表示生物不是神话中的。

现在，让我们使用目标编码来编码分类列。目标编码将执行以下步骤：

1. 将分类值分组，并记录给定类别中目标值神话为1和为0的次数如下：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_027.jpg

图 3.27 – 带有目标计数的神话生物数据集

1. 计算在特定组内1的目标值发生的概率，与0的目标值相比。这看起来如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_028.jpg

图 3.28 – 带有目标 1 发生概率列的神话生物数据集

1. 删除动物列，并使用目标 1 发生概率列作为动物列的编码表示。新的编码数据集将如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_029.jpg

图 3.29 – 目标编码的神话生物数据集

在编码数据集中，动物特征使用目标编码进行编码，我们得到了一个完全数值化的数据集。这个数据集将很容易被机器学习算法解释和学习，从而提供高质量的模型。

让我们看看如何使用 H2O 进行目标编码。我们将使用此示例的汽车价格预测数据集。您可以在archive.ics.uci.edu/ml/datasets/Automobile（Dua, D. 和 Graff, C. (2019). UCI 机器学习库[archive.ics.uci.edu/ml]。加州大学欧文分校信息与计算机科学学院，加州，欧文）找到该数据集的详细信息。

该数据集相当直接。它包含有关汽车的各种详细信息，例如汽车的制造商、发动机尺寸、燃油系统、压缩比和价格。机器学习算法的目标是根据这些特征预测汽车的价格。

在我们的实验中，我们将使用目标编码对categorical列make、fuel type和body style进行编码，其中price列是目标。

让我们按照以下示例执行目标编码：

1. 导入h2o和 H2O 的H2OTargetEncoderEstimator，并初始化你的 H2O 服务器。执行以下代码：

   import h2o
   from h2o.estimators import H2OTargetEncoderEstimator
   h2o.init()
   

2. 导入Automobile price prediction数据集并打印数据集的内容。执行以下代码：

   automobile_dataframe = h2o.import_file(" Dataset\Automobile_data.csv" )
   automobile_dataframe
   

让我们观察数据框的内容；它应该如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_030.jpg

图 3.30 – 汽车价格预测数据框

如前图所示，数据框包含大量列，其中包含汽车的详细信息。为了理解目标编码，让我们筛选出我们想要实验的列，同时删除其余的列。由于我们计划对make列、fuel-type列和body-style列进行编码，让我们只使用这些列以及price响应列。执行以下代码：

automobile_dataframe = automobile_dataframe[:,[" make" , " fuel-type" , " body-style" , " price" ]]
automobile_dataframe

过滤后的数据框将如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_031.jpg

图 3.31 – 过滤列的汽车价格预测数据框

1. 现在让我们将这个数据框拆分为训练数据框和测试数据框。执行以下代码：

   automobile_dataframe_for_training, automobile_dataframe_for_test = automobile_dataframe.split_frame(ratios = [.8], seed = 123)
   

2. 现在让我们使用H2OTargetEncoderEstimator训练我们的目标编码器模型。执行以下代码：

   automobile_te = H2OTargetEncoderEstimator()
   automobile_te.train(x= [" make" , " fuel-type" , " body-style" ], y=" price" , training_frame=automobile_dataframe_for_training)
   

一旦目标编码器完成训练，你将看到以下输出：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_032.jpg

图 3.32 – 目标编码器训练的结果

从前面的截图可以看出，H2O 目标编码器将为make列、fuel-type列和body-style列生成目标编码值，并分别存储在不同的名为make_te、fuel-type_te和body-style_te的列中。这些新列将包含编码值。

1. 现在让我们使用这个训练过的目标编码器对训练数据集进行编码并打印编码后的数据框：

   te_automobile_dataframe_for_training = automobile_te.transform(frame=automobile_dataframe_for_training, as_training=True)
   te_automobile_dataframe_for_training
   

编码后的训练帧应如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_033.jpg

图 3.33 – 编码的汽车价格预测训练数据框

如图中所示，我们的训练帧现在有三个额外的列，make_te、fuel-type_te和body-style_te，包含数值。这些是make列、fuel-type列和body-style列的目标编码列。

1. 同样，现在让我们使用训练好的目标编码器来编码测试数据框架，并打印编码后的数据框架。执行以下代码：

   te_automobile_dataframe_for_test = automobile_te.transform(frame=automobile_dataframe_for_test, noise=0)
   te_automobile_dataframe_for_test
   

编码后的测试框架应如下所示：

https://github.com/OpenDocCN/freelearn-ml-zh/raw/master/docs/prac-auto-ml-h2o/img/B17298_03_034.jpg

图 3.34 – 编码的汽车价格预测测试数据框架

如您从图中所示，我们的测试框架也有三个额外的列，这些是编码列。现在您可以使用这些数据框架来训练您的机器学习模型。

根据您的下一步行动，您可以使用编码后的数据框架以您认为合适的方式。如果您想使用数据框架来训练机器学习模型，那么您可以删除数据框架中的分类列，并使用相应的编码列作为训练特征来训练您的模型。如果您希望对数据集进行任何进一步的统计分析，那么您可以保留这两种类型的列，并进行任何比较研究。

小贴士

H2O 的目标编码器有几个参数可以设置以调整编码过程。根据您正在处理的数据类型，为目标编码数据集选择正确的设置可能会变得非常复杂。因此，请随意尝试这个功能，因为您对这个功能和目标编码的一般理解越好，您就能更好地编码数据框架并进一步提高模型训练。您可以在以下位置找到有关 H2O 目标编码器的更多详细信息：docs.h2o.ai/h2o/latest-stable/h2o-docs/data-science/target-encoding.xhtml。

恭喜！您刚刚了解了如何使用 H2O 的目标编码器对分类值进行编码。

摘要

在本章中，我们首先探讨了我们在将数据框架发送到模型训练之前所使用的各种技术和一些常见函数，以预处理我们的数据框架。我们探讨了如何将原始数据框架重新构建成适合的、一致的格式，以满足模型训练的要求。我们学习了如何通过将不同数据框架的不同列组合起来来操作数据框架的列。我们还学习了如何从分区数据框架中组合行，以及如何直接将数据框架合并成一个单一的数据框架。

一旦我们学会了如何重新构建我们的数据框架，我们就学会了如何处理新收集的数据中经常出现的缺失值。我们学会了如何填充 NA 值，替换某些错误值，以及如何使用不同的插补策略来避免在填充缺失值时添加噪声和偏差。

然后，我们研究了如何通过按列排序数据框架以及更改列的类型来操作特征列。我们还学习了如何对字符串进行标记化以处理文本数据，以及如何使用 H2O 的目标编码器对分类值进行编码。

在下一章中，我们将打开 AutoML 的“黑箱”，探索其训练过程，以及 AutoML 过程中内部发生的事情。这将帮助我们更好地理解 H2O 如何施展魔法并高效地自动化模型训练过程。