Hadoop-和-R-大数据分析-全-

Hadoop 和 R 大数据分析（全）

原文：Big Data Analytics with R and Hadoop

协议：CC BY-NC-SA 4.0

零、前言

企业每天获取的数据量呈指数级增长。现在可以在 Hadoop 等低成本平台上存储这些海量信息。

这些组织现在面临的难题是如何处理所有这些数据，以及如何从这些数据中收集关键见解。于是，R 出现了。r 是一个非常神奇的工具，它可以很容易地对数据运行高级统计模型，将导出的模型转换成彩色图形和可视化，并执行更多与数据科学相关的功能。

然而，R 的一个主要缺点是它的可扩展性不是很好。核心 R 引擎可以处理和处理非常有限的数据。由于 Hadoop 在大数据处理中非常受欢迎，因此将 R 与 Hadoop 对应起来以实现可扩展性是下一个逻辑步骤。

这本书专门介绍了 R 和 Hadoop，以及 R 的数据分析操作如何通过使用 Hadoop 这样的平台进行扩展的复杂性。

考虑到这一议程，这本书将迎合广泛的受众，包括数据科学家、统计学家、数据架构师和工程师，他们正在寻找使用 R 和 Hadoop 处理和分析大量信息的解决方案。

在 Hadoop 中使用 R 将提供一个弹性数据分析平台，该平台将根据要分析的数据集的大小进行扩展。然后，有经验的程序员可以在 R 中编写 Map/Reduce 模块，并使用 Hadoop 的并行处理 Map/Reduce 机制来运行它，以识别数据集中的模式。

引入 R

r 是一个对数据进行统计分析的开源软件包。r 是数据科学家、统计学家和其他人使用的编程语言，他们需要对数据进行统计分析，并使用回归、聚类、分类和文本分析等机制从数据中收集关键见解。r 注册于 GNU ( 通用公共许可证)。它是由新西兰奥克兰大学的罗斯·伊哈卡和罗伯特·绅士开发的，目前由研发核心团队负责。它可以被认为是由贝尔实验室的约翰·钱伯斯开发的 S 的不同实现。有一些重要的区别，但是使用 R 解释器引擎，很多用 S 编写的代码可以保持不变。

r 提供多种统计、机器学习(线性和非线性建模、经典统计测试、时间序列分析、分类、聚类)和图形技术，并且具有高度可扩展性。r 具有各种内置和扩展的统计、机器学习和可视化任务功能，例如:

  • 数据析取
  • 数据清理
  • 数据加载
  • 数据转换
  • 统计分析
  • 预测建模
  • 数据可视化

它是当今市场上最受欢迎的开源统计分析包之一。它是跨平台的，拥有非常广泛的社区支持，以及每天都在添加新包的庞大且不断增长的用户社区。随着包列表的不断增加，R 现在可以与其他数据存储连接，例如 MySQL、SQLite、MongoDB 和 Hadoop，用于数据存储活动。

理解 R 的特征

让我们看看 R 的不同有用特性:

  • 有效的编程语言
  • 关系数据库支持
  • 数据分析
  • 数据可视化
  • 通过庞大的 R 包库进行扩展

研究 R 的流行

KD 提供的图表表明 R 是最流行的数据分析和挖掘语言:

Studying the popularity of R

下图提供了 2005 年至 2013 年 R 用户发布的 R 包总数的详细信息。这就是我们探索 R 用户的方式。2012 年的增长率是指数级的，2013 年似乎有望超过这一数字。

r 允许通过各种统计和机器学习操作执行数据分析，如下所示:

  • 回归
  • 分类
  • 使聚集
  • 建议
  • 文本挖掘

Studying the popularity of R

引入大数据

大数据必须处理大型复杂的数据集，这些数据集可以是结构化的、半结构化的或非结构化的，并且通常不适合要处理的内存。它们必须就地处理，这意味着计算必须在数据所在的地方进行。当我们与实际构建大数据系统和应用的开发人员交谈时，我们会更好地理解他们对 3Vs 的理解。他们通常会提到大数据的 3Vs 模型，即速度、容量和多样性。

速度是指需要应用分析的低延迟、实时速度。这方面的一个典型例子是对源自社交网站的连续数据流或不同数据源的聚合进行分析。

体积是指数据集的大小。它可能以 KB、MB、GB、TB 或 PB 为单位，具体取决于生成或接收数据的应用的类型。

多样性是指可能存在的各种类型的数据，例如文本、音频、视频和照片。

大数据通常包括大小不一的数据集。此类系统不可能在业务要求的时间范围内处理如此大量的数据。大数据量是一个不断变化的目标，截至 2012 年，单个数据集中的数据量从几十万亿字节到几千兆字节不等。面对这个看似不可逾越的挑战，全新的平台被称为大数据平台。

Introducing Big Data

获取有关持有大数据的热门组织的信息

持有大数据的一些流行组织如下:

  • 脸书:它有 40 PB 的数据，每天捕获 100 TB
  • 雅虎！:它有 60 PB 的数据
  • 推特:它每天捕获 8 TB
  • 易趣:它有 40 PB 的数据，每天捕获 50 TB

有多少数据被视为大数据因公司而异。虽然一家公司的大数据是另一家公司的小数据，但有一个共同点:既不适合内存，也不适合磁盘，有大量需要处理的数据，并且将受益于分布式软件堆栈。对于一些公司，10 TB 的数据将被视为大数据，而对于其他公司，1 PB 的数据将被视为大数据。所以只有你能确定数据是否真的是大数据。可以说，它将从低太字节范围开始。

此外，一个非常值得问的问题是，由于您没有捕获和保留足够的数据，您认为您现在没有大数据问题吗？在某些情况下，公司确实会丢弃数据，因为没有一种经济高效的方法来存储和处理数据。有了 Hadoop 这样的平台，就有可能开始捕获和存储所有这些数据。

介绍 Hadoop

Apache Hadoop 是一个开源的 Java 框架，用于处理和查询大型商品硬件集群上的大量数据。Hadoop 是一个顶级的 Apache 项目，由雅虎发起和领导！还有道格·卡特。它的成功有赖于来自世界各地的积极贡献者。

通过雅虎的大量技术投资！，Apache Hadoop 已经成为企业级的云计算技术。它正在成为行业事实上的大数据处理框架。

Hadoop 改变了大规模计算的经济和动态。它的影响可以归结为四个显著特征。Hadoop 支持可扩展、经济高效、灵活、容错的解决方案。

探索 Hadoop 特性

Apache Hadoop 有两个主要特性:

  • HDFS (Hadoop 分布式文件系统)
  • MapReduce

研究 Hadoop 组件

Hadoop 包括在核心 HDFS 和 MapReduce 层上构建的其他产品生态系统，以支持平台上的各种类型的操作。一些流行的 Hadoop 组件如下:

  • Mahout :这是一个庞大的机器学习算法库。
  • Pig : Pig 是一种分析大型数据集的高级语言(如 PERL)，有自己的语言语法来表达数据分析程序，再加上评估这些程序的基础设施。
  • Hive : Hive 是一个面向 Hadoop 的数据仓库系统，可以方便地进行数据汇总、即席查询以及分析存储在 HDFS 的大型数据集。它有自己的类似 SQL 的查询语言，叫做Hive 查询语言 ( HQL )，用来向 Hadoop 发出查询命令。
  • HBase:HBase(Hadoop 数据库)是一个分布式、面向列的数据库。HBase 使用 HDFS 作为底层存储。它支持使用 MapReduce 的批处理风格计算和原子查询(随机读取)。
  • Sqoop : Apache Sqoop 是一款专为在 Hadoop 和结构化关系数据库之间高效传输海量数据而设计的工具。 Sqoop 是( SQ )L 到 Had( oop 的缩写。
  • ZooKeeper:ZooKeeper 是维护配置信息、命名、提供分布式同步、分组服务的集中式服务，对于各种分布式系统非常有用。
  • Ambari :基于 web 的工具，用于供应、管理和监控 Apache Hadoop 集群，包括对 Hadoop HDFS、Hadoop MapReduce、Hive、HCatalog、HBase、ZooKeeper、Oozie、Pig 和 Sqoop 的支持。

了解一起使用 R 和 Hadoop 的原因

我还要说，有时数据驻留在 HDFS(以各种格式)。由于许多数据分析师在 R 中的工作效率很高，因此使用 R 来计算通过 Hadoop 相关工具存储的数据是很自然的。

如前所述，R 的优势在于其使用丰富的包库分析数据的能力，但在处理非常大的数据集时却有所欠缺。另一方面，Hadoop 的优势是存储和处理 TB 甚至 PB 范围内的大量数据。如此庞大的数据集无法在内存中处理，因为每台机器的内存无法容纳如此大的数据集。选项将是在有限的块上运行分析，也称为采样，或者将 R 的分析能力与 Hadoop 的存储和处理能力对应起来，您将获得一个理想的解决方案。这样的解决方案也可以使用亚马逊 EMR 等平台在云中实现。

这本书涵盖了什么

第一章、准备使用 R 和 Hadoop ，介绍了安装 R 和 Hadoop 的过程。

第二章、编写 Hadoop MapReduce 程序，介绍 Hadoop MapReduce 的基础知识以及使用 Hadoop 执行 MapReduce 的方法。

第 3 章、集成 R 和 Hadoop ，展示了通过各种数据处理流程部署和运行 RHadoop 和 RHIPE 的示例 MapReduce 程序。

第四章、用 R 使用 Hadoop Streaming，展示如何用 R 使用 Hadoop Streaming

第 5 章、用 R 和 Hadoop 学习数据分析，通过用真实数据分析问题进行演示，介绍数据分析项目生命周期。

第 6 章、用机器学习理解大数据分析，涵盖了用 RHadoop 通过机器学习技术执行大数据分析。

第 7 章、从各种数据库导入和导出数据，介绍了如何与流行的关系数据库接口，用 r

附录、参考文献，描述了与所有章节内容相关的附加资源的链接。

这本书你需要什么

由于我们将使用 R 和 Hadoop 执行大数据分析，您应该具备 R 和 Hadoop 的基本知识以及如何执行实践，并且您需要安装和配置 R 和 Hadoop。如果你已经有了更大规模的数据和问题定义，可以用数据驱动的技术来解决，比如 R 和 Hadoop 函数，那就太好了。

这本书是给谁的

这本书非常适合正在寻找用 Hadoop 执行大数据分析的方法的研发人员。他们想要集成 R 和 Hadoop 的所有技术，如何编写 Hadoop MapReduce，以及在 R 中开发和运行 Hadoop MapReduce 的教程。此外，这本书面向那些了解 Hadoop 并希望使用 R 包在大数据上构建一些智能应用的人。如果读者有 r 的基础知识会有帮助。

惯例

在这本书里，你会发现许多区分不同种类信息的文本风格。以下是这些风格的一些例子，以及对它们的含义的解释。

文本中的码字、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟网址、用户输入和推特句柄如下所示:“准备Map()输入。”

代码块设置如下:

<property>
<name>mapred.job.tracker</name>
<value>localhost:54311</value>
<description>The host and port that the MapReduce job tracker runs
at. If "local", then jobs are run in-process as a single map
and reduce task.
</description>
</property>

任何命令行输入或输出都编写如下:

// Setting the environment variables for running Java and Hadoop commands
export HADOOP_HOME=/usr/local/hadoop
export JAVA_HOME=/usr/lib/jvm/java-6-sun

新名词和重要词语以粗体显示。你在屏幕上看到的单词，例如在菜单或对话框中，出现在如下文本中:“打开密码标签。”。

注

警告或重要提示会出现在这样的框中。

类型

提示和技巧是这样出现的。

读者反馈

我们随时欢迎读者的反馈。让我们知道你对这本书的看法——你喜欢或可能不喜欢什么。读者反馈对我们开发您真正能从中获得最大收益的标题非常重要。

要给我们发送一般反馈，只需向<[feedback@packtpub.com](mailto:feedback@packtpub.com)>发送电子邮件，并通过您的消息主题提及书名。

如果你对某个主题有专业知识，并且对写作或投稿感兴趣，请参阅我们在www.packtpub.com/authors上的作者指南。

客户支持

现在，您已经自豪地拥有了一本书，我们有许多东西可以帮助您从购买中获得最大收益。

下载示例代码

您可以从您在http://www.packtpub.com的账户中下载您购买的所有 Packt 书籍的示例代码文件。如果您在其他地方购买了这本书，您可以访问http://www.packtpub.com/support并注册，以便将文件直接通过电子邮件发送给您。

勘误表

尽管我们尽了最大努力来确保我们内容的准确性，但错误还是会发生。如果你在我们的某本书里发现了错误——可能是文本或代码中的错误——如果你能向我们报告，我们将不胜感激。通过这样做，你可以让其他读者免受挫折，并帮助我们改进这本书的后续版本。如果您发现任何勘误表，请访问http://www.packtpub.com/submit-errata，选择您的书籍，点击勘误表 提交 表格链接，并输入您的勘误表详情。一旦您的勘误表得到验证，您的提交将被接受，勘误表将上传到我们的网站上，或添加到该标题的勘误表部分下的任何现有勘误表列表中。通过从http://www.packtpub.com/support中选择您的标题，可以查看任何现有的勘误表。

盗版

互联网上版权材料的盗版是所有媒体的一个持续问题。在 Packt，我们非常重视版权和许可证的保护。如果您在互联网上遇到任何形式的我们作品的非法拷贝，请立即向我们提供位置地址或网站名称，以便我们寻求补救。

请通过<[copyright@packtpub.com](mailto:copyright@packtpub.com)>联系我们，获取疑似盗版资料的链接。

我们感谢您在保护我们作者方面的帮助，以及我们为您带来有价值内容的能力。

问题

如果您对本书的任何方面有问题，可以在<[questions@packtpub.com](mailto:questions@packtpub.com)>联系我们，我们将尽最大努力解决。

一、准备使用 R 和 Hadoop

第一章与关于 R 和 Hadoop 基础的几个主题捆绑在一起，如下所示:

  • 安装、特性和数据建模
  • Hadoop 安装、功能和组件

在前言中，我们向您介绍了 R 和 Hadoop。本章将重点介绍如何使用这两种技术让你起床和跑步。到目前为止，R 主要用于统计分析，但由于功能和包的数量不断增加，在机器学习、可视化、数据操作等几个领域变得流行起来。r 不会将所有数据(大数据)加载到机器内存中。因此，可以选择 Hadoop 作为大数据加载数据。并不是所有的算法都在 Hadoop 上运行，并且这些算法通常不是 R 算法。尽管如此，使用 R 进行分析仍有几个与大数据相关的问题。为了分析数据集，R 将其加载到内存中，如果数据集很大，则会出现“无法分配大小为 x 的向量”等异常失败。因此，为了处理大型数据集，R 的处理能力可以通过将其与 Hadoop 集群的能力相结合来大大放大。Hadoop 是一个非常流行的框架，它提供了这样的并行处理能力。因此，我们可以在 Hadoop 集群上使用 R 算法或分析处理来完成工作。

Getting Ready to Use R and Hadoop

如果我们考虑一个组合的 RHadoop 系统，R 将负责具有初步功能的数据分析操作，例如数据加载、探索、分析和可视化，Hadoop 将负责并行数据存储以及针对分布式数据的计算能力。

在经济实惠的大数据技术出现之前，分析通常在单台机器上的有限数据集上运行。当应用于大型数据集时，高级机器学习算法非常有效，这只有在大型集群中才有可能，在大型集群中，数据可以通过分布式数据存储系统进行存储和处理。在下一节中，我们将看到如何在不同的操作系统上安装 R 和 Hadoop，以及链接 R 和 Hadoop 的可能方式。

安装 R

你可以通过访问 R 官方网站下载合适的版本。

以下是为三种不同操作系统提供的步骤。我们考虑了 Windows、Linux、Mac OS 进行 R 安装。下载最新版本的 R，因为它将有所有最新的补丁和解决过去的错误。

对于 Windows，请遵循给定的步骤:

  1. 导航至www.r-project.org。
  2. 点击 CRAN 部分，选择 CRAN 镜像，选择你的 Windows OS(坚持 LinuxHadoop 几乎总是在 Linux 环境中使用)。
  3. 从镜像下载最新的 R 版本。
  4. 执行下载的.exe安装 r。

对于 Linux-Ubuntu，请遵循给定的步骤:

  1. 导航至www.r-project.org。
  2. 点击 CRAN 部分，选择 CRAN 镜像，选择你的操作系统。
  3. 在/etc/apt/sources.list文件中，添加 CRAN <mirror>条目。
  4. 使用sudo apt-get update命令从存储库中下载并更新包列表。
  5. 使用sudo apt-get install r-base命令安装 R 系统。

对于 Linux-RHEL/CentOS，请遵循给定的步骤:

  1. 导航至www.r-project.org。
  2. 点击 CRAN ，选择 CRAN 镜像，选择红帽 OS。
  3. 下载R-*core-*.rpm文件。
  4. 使用rpm -ivh R-*core-*.rpm命令安装.rpm包。
  5. 使用sudo yum install R安装 R 系统。

对于 Mac，请遵循给定的步骤:

  1. 导航至www.r-project.org。
  2. 点击 CRAN ，选择 CRAN 镜像，选择你的操作系统。
  3. 下载以下文件:pkg、gfortran-*.dmg、tcltk-*.dmg。
  4. 安装R-*.pkg文件。
  5. 然后，安装gfortran-*.dmg和tcltk-*.dmg文件。

安装基础 R 包后，建议安装 RStudio，这是一个强大直观的 R集成开发环境 ( IDE )

类型

我们可以使用革命分析的 R 分布作为统计计算和预测分析的现代数据分析工具，该工具有免费版本和高级版本。Hadoop 集成也可用于执行大数据分析。

安装 RStudio

要安装 RStudio，请执行以下步骤:

  1. 导航至http://www.rstudio.com/ide/download/desktop。
  2. 为您的操作系统下载最新版本的 RStudio。
  3. 执行安装程序文件并安装 RStudio。

RStudio 组织和用户社区已经开发了很多用于图形和可视化的 R 包，例如ggplot2、plyr、Shiny、Rpubs和devtools。

理解 R 语言的特点

有超过 3000 个 R 包，而且这个列表还在日益增长。甚至试图解释所有这些包都超出了任何一本书的范围。本书只关注 R 的关键特性和最常用、最受欢迎的包。

使用 R 包

R 包是可以作为函数调用的独立的 R 功能单元。一个很好的类比是 Java 中的一个.jar文件。有一个庞大的 R 包库，可用于从统计操作和机器学习到丰富的图形可视化和绘图等非常广泛的操作。每个包将由一个或多个 R 函数组成。R 包是一个可重用的实体，可以被其他人共享和使用。r 用户可以安装包含他们正在寻找的功能的包，并开始调用包中的功能。这些包裹的综合清单可以在名为综合 R 档案网 ( CRAN )的http://cran.r-project.org/找到。

执行数据操作

r 允许大范围的操作。统计运算，如均值、最小值、最大值、概率、分布、回归。机器学习操作，如线性回归、逻辑回归、分类和聚类。通用数据处理操作如下:

  • 数据清理:这个选项是清理海量数据集
  • 数据探索:这个选项是探索数据集所有可能的值
  • 数据分析:这个选项是用描述性和预测性分析数据可视化对数据进行分析，也就是分析输出编程的可视化

为了构建一个有效的分析应用，有时我们需要使用在线的应用编程接口 ( API )来挖掘数据，用权宜服务进行分析，并通过第三方服务进行可视化。此外，为了自动化数据分析过程，编程将是最有用的特性。

r 有自己的编程语言来操作数据。此外，可用的软件包可以帮助将 R 与其他编程功能集成在一起。r 支持面向对象编程概念。它还能够与其他编程语言集成，如 Java、PHP、C 和 C++。有几个包将作为中间层编程特性来帮助数据分析，它们类似于sqldf、httr、RMongo、RgoogleMaps、RGoogleAnalytics和google-prediction-api-r-client。

增加社区支持

随着 R 用户数量不断升级，与 R 相关的群体也在不断增加。因此，R 学习者或开发人员可以在几个 R 小组或社区的帮助下轻松连接并解决他们的不确定性。

以下是许多常见的有用信息来源:

  • R 邮件列表:这个是 R 项目业主创建的官方 R 群。
  • R 博客 : R 有无数的博主在几个 R 应用上写文章。最受欢迎的博客网站之一是http://www.r-bloggers.com/，所有的博主都在这里投稿。
  • 栈溢出:这个是一个很棒的技术知识共享平台，程序员可以在这里发布自己的技术查询，发烧友程序员建议解决方案。更多信息，请访问http://stats.stackexchange.com/。
  • 小组:LinkedIn 和 Meetup 上还有许多其他小组，世界各地的专业人士聚集在一起讨论他们的问题和创新想法。
  • 书籍:也有很多关于 R 的书籍，其中比较受欢迎的有 R in Action 、 Rob Kabacoff 、 Manning Publications 、R in absolute、 Joseph Adler 、 O'Reilly Media 、 R and Data Mining 、颜长昭、【t1t

在 R 中进行数据建模

数据建模是一种从历史数据集中识别隐藏模式的机器学习技术，这种模式将有助于对相同数据的未来值预测。这种技术高度关注过去的用户行为，并学习他们的品味。这些数据建模技术中的大多数已经被许多流行的组织所采用，以根据他们过去的交易来了解他们的客户的行为。这些技术将分析数据，并为客户预测他们在寻找什么。亚马逊、谷歌、脸书、易贝、领英、推特和许多其他组织正在使用数据挖掘来改变应用的定义。

最常见的数据挖掘技术如下:

  • 回归:在统计学中，回归是通过在变量值上拟合状态线来识别两个或多个变量之间的标量关系的经典技术。这种关系将有助于预测未来事件的变量值。例如，任何变量 y 都可以用公式 y = mx+c 建模为另一个变量 x 的线性函数。这里，x 是预测变量，y 是响应变量，m 是直线的斜率，c 是截距。产品或服务的销售预测和股票价格预测可以通过这种回归来实现。r 通过lm方法提供这种回归特征，默认情况下在 r 中存在
  • 分类:这是一种机器学习技术，用于标记为训练示例而提供的观察集。有了这个，我们可以将观察分类到一个或多个标签中。销售的可能性、在线欺诈检测和癌症分类(用于医学)是分类问题的常见应用。谷歌邮件使用这种技术将电子邮件分类为垃圾邮件。r 中的glm、glmnet、ksvm、svm和randomForest可以提供分类功能
  • 聚类:这种技术是从给定的项目集合中将相似的项目组织成组。用户分割和图像压缩是聚类最常见的应用。市场细分、社会网络分析、组织计算机聚类和天文数据分析都是聚类的应用。谷歌新闻使用这些技术将相似的新闻项目归入同一类别。聚类可以通过 r 中的knn、kmeans、dist、pvclust和Mclust方法实现
  • 推荐:推荐算法用于推荐系统，其中系统是目前使用的最容易识别的机器学习技术。网络内容推荐可能包括类似的网站、博客、视频或相关内容。此外，网上商品的推荐有助于交叉销售和追加销售。我们都见过网上购物门户网站试图根据用户过去的行为推荐书籍、手机或任何可以在网上出售的商品。亚马逊是一个著名的电子商务门户网站，通过推荐系统产生 29%的销售额。推荐器系统可以通过Recommender()用 r 中的recommenderlab包来实现

安装 Hadoop

现在，我们假设您知道 R，它是什么，如何安装它，它的关键功能是什么，以及为什么您可能想要使用它。现在我们需要知道 R 的局限性(这是对 Hadoop 更好的介绍)。在处理数据之前；r 需要将数据加载到随机存储器 ( RAM )中。因此，数据需要小于可用的机器内存。对于大于机器内存的数据，我们将其视为大数据(仅在我们的情况下，因为大数据有许多其他定义)。

为了避免这个大数据问题，我们需要扩展硬件配置；然而，这是一个临时的解决方案。为了解决这个问题，我们需要一个 Hadoop 集群，能够存储它并在大型计算机集群上执行并行计算。Hadoop 是最受欢迎的解决方案。Hadoop 是一个开源的 Java 框架，是 Apache 软件基金会处理的顶级项目。Hadoop 的灵感来自谷歌文件系统和 MapReduce，主要设计用于通过分布式处理对大数据进行操作。

Hadoop 主要支持 Linux 操作系统。要在 Windows 上运行，我们需要使用 VMware 在 Windows 操作系统中托管 Ubuntu。使用和安装 Hadoop 的方法有很多，但这里我们会考虑最支持 R 的方式。在我们结合 R 和 Hadoop 之前，让我们先了解一下什么是 Hadoop。

类型

机器学习包含了所有可以通过网络链接http://en.wikipedia.org/wiki/Machine_learning探索的数据建模技术。

Michael Noll 关于 Hadoop 安装的结构博客可以在http://www . Michael-Noll . com/tutorials/running-Hadoop-on-Ubuntu-Linux-单节点-cluster/ 找到。

了解不同的 Hadoop 模式

Hadoop 与三种不同的模式一起使用:

  • 独立模式:在这个模式下，你不需要启动任何 Hadoop 守护程序。取而代之的是，只需调用~/Hadoop-directory/bin/hadoop，它将作为单个 Java 进程执行一个 Hadoop 操作。出于测试目的，建议这样做。这是默认模式，您不需要配置其他任何东西。所有守护程序，如名称节点、数据节点、作业跟踪器和任务跟踪器，都在一个 Java 进程中运行。
  • 伪模式:在这个模式下，你为所有节点配置 Hadoop。一个单独的 Java 虚拟机 ( JVM ) 是为每个 Hadoop 组件或守护程序(如单个主机上的迷你集群)生成的。
  • 全分布式模式:在这种模式下，Hadoop 分布在多台机器上。专用主机是为 Hadoop 组件配置的。因此，所有守护程序都有单独的 JVM 进程。

了解 Hadoop 安装步骤

Hadoop 可以通过几种方式安装；我们将考虑更好地与 r 集成的方式，我们将选择 Ubuntu 操作系统，因为它易于安装和访问。

  1. 在 Linux 上安装 Hadoop，Ubuntu 风格(单节点和多节点集群)。
  2. 在 Ubuntu 上安装 Cloudera Hadoop。

在 Linux 上安装 Hadoop，Ubuntu 风味(单节点集群)

要以伪模式在 Ubuntu 操作系统上安装 Hadoop，我们需要满足以下先决条件:

  • Sun Java 6
  • 专用 Hadoop 系统用户
  • 配置 SSH
  • 禁用 IPv6

类型

所提供的 Hadoop 安装将支持 Hadoop MRv1。

按照给定的步骤安装 Hadoop:

  1. 从 Apache 软件基金会下载最新的 Hadoop 源代码。这里我们考虑了 Apache Hadoop 1.0.3，而最新版本是 1.1.x.

    // Locate to Hadoop installation directory
$ cd /usr/local

// Extract the tar file of Hadoop distribution
$ sudo tar xzf hadoop-1.0.3.tar.gz

// To move Hadoop resources to hadoop folder 
$ sudo mv hadoop-1.0.3 hadoop

// Make user-hduser from group-hadoop as owner of hadoop directory
$ sudo chown -R hduser:hadoop hadoop

  2. 将$JAVA_HOME和$HADOOP_HOME变量添加到 Hadoop 系统用户的.bashrc文件中，更新后的.bashrc文件如下:

    // Setting the environment variables for running Java and Hadoop commands
export HADOOP_HOME=/usr/local/hadoop
export JAVA_HOME=/usr/lib/jvm/java-6-sun

// alias for Hadoop commands
unalias fs &> /dev/null
alias fs="hadoop fs"
unalias hls &> /dev/null
aliashls="fs -ls"

// Defining the function for compressing the MapReduce job output by lzop command
lzohead () {
hadoopfs -cat $1 | lzop -dc | head -1000 | less
}

// Adding Hadoop_HoME variable to PATH 
export PATH=$PATH:$HADOOP_HOME/bin

  3. 用conf/*-site.xml格式更新 Hadoop 配置文件。

最后，这三个文件将如下所示:

  • conf/core-site.xml :

    <property>
<name>hadoop.tmp.dir</name>
<value>/app/hadoop/tmp</value>
<description>A base for other temporary directories.</description>
</property>
<property>
<name>fs.default.name</name>
<value>hdfs://localhost:54310</value>
<description>The name of the default filesystem. A URI whose
scheme and authority determine the FileSystem implementation. The
uri's scheme determines the config property (fs.SCHEME.impl) naming
theFileSystem implementation class. The uri's authority is used to
determine the host, port, etc. for a filesystem.</description>
</property>

  • conf/mapred-site.xml :

    <property>
<name>mapred.job.tracker</name>
<value>localhost:54311</value>
<description>The host and port that the MapReduce job tracker runs
at. If "local", then jobs are run in-process as a single map
and reduce task.
</description>
</property>

  • conf/hdfs-site.xml :

    <property>
<name>dfs.replication</name>
<value>1</value>
<description>Default block replication.
  The actual number of replications can be specified when the file is created.
  The default is used if replication is not specified in create time.
</description>

在完成对这些配置文件的编辑后，我们需要跨 Hadoop 集群或节点设置分布式文件系统。

  • 使用以下命令行通过名称节点格式化 Hadoop 分布式文件系统 ( HDFS )

  • 使用以下命令行启动单节点集群:

    hduser@ubuntu:~$ /usr/local/hadoop/bin/start-all.sh

类型

下载示例代码

您可以在http://www.packtpub.com从您的账户中下载您购买的所有 Packt 书籍的示例代码文件。如果您在其他地方购买了这本书，您可以访问http://www.packtpub.com/support并注册，以便将文件直接通过电子邮件发送给您。

在 Linux 上安装 Hadoop，Ubuntu 风味(多节点集群)

我们学习了如何在单节点集群上安装 Hadoop。现在我们将看到如何在多节点集群(全分布式模式)上安装 Hadoop 。

为此，我们需要几个配置了单节点 Hadoop 集群的节点。要在多节点上安装 Hadoop，我们需要为该机器配置单节点 Hadoop 集群，如上一节所述。

安装单节点 Hadoop 集群后，我们需要执行以下步骤:

  1. 在网络阶段，我们将使用两个节点来设置完全分布式 Hadoop 模式。为了相互通信，就软件和硬件配置而言，节点需要在同一网络中。

  2. 在这两个节点中，一个节点将被视为主节点，另一个节点将被视为从节点。因此，为了执行 Hadoop 操作，主机需要连接到从机。我们将在主机中输入192.168.0.1，在从机中输入192.168.0.2。

  3. Update the /etc/hosts directory in both the nodes. It will look as 192.168.0.1 master and 192.168.0.2 slave.

    类型

    您可以执行 安全外壳 ( SSH )设置，类似于我们对单节点集群设置所做的。更多详情，请访问http://www.michael-noll.com。

  4. 更新conf/*-site.xml:我们必须改变所有节点中的所有这些配置文件。

    • conf/core-site.xml和conf/mapred-site.xml:在单节点设置中，我们已经更新了这些文件。所以，现在我们只需要在价值标签中将localhost替换为master。
    • conf/hdfs-site.xml:在单节点设置中，我们已经将dfs.replication的值设置为1。现在我们需要更新为2。

  5. 在格式化 HDFS 阶段，在我们开始多节点集群之前，我们需要使用以下命令格式化 HDFS(从主节点):

    bin/hadoop namenode -format

现在，我们已经完成了安装多节点 Hadoop 集群的所有步骤。要启动 Hadoop 集群，我们需要遵循以下步骤:

  1. 启动 HDFS 守护程序:

    hduser@master:/usr/local/hadoop$ bin/start-dfs.sh

  2. 启动 MapReduce 守护程序:

    hduser@master:/usr/local/hadoop$ bin/start-mapred.sh

  3. 或者，我们可以用一个命令启动所有守护进程:

    hduser@master:/usr/local/hadoop$ bin/start-all.sh

  4. 要停止所有这些守护程序，请激发:

    hduser@master:/usr/local/hadoop$ bin/stop-all.sh

这些安装步骤是受欧洲瑞士研究员兼软件工程师迈克尔·诺尔的博客(http://www.michael-noll.com)启发后复制的。他在 VeriSign 担任 Apache Hadoop 堆栈上的大规模计算基础设施的技术主管。

现在，Hadoop 集群已经在您的机器上设置好了。要在具有扩展 Hadoop 组件的单节点或多节点上安装相同的 Hadoop 集群，请尝试 Cloudera 工具。

在 Ubuntu 上安装 Cloudera Hadoop

Cloudera Hadoop(CDH)是 Cloudera 的开源发行版，面向企业级部署的 Hadoop 技术。Cloudera 也是 Apache 软件基金会的赞助商。CDH 有两个版本:CDH3 和 CDH4。要安装其中的一个，您必须拥有带有 10.04 LTS 或 12.04 LTS 的 Ubuntu(此外，您还可以尝试 CentOS、Debian 和红帽系统)。如果您在计算机集群上安装 Hadoop，Cloudera manager 将使您的安装更加容易，该集群在整个集群上提供基于图形用户界面的 Hadoop 及其组件安装。这个工具非常适合大型集群。

我们需要满足以下前提条件:

  • 配置 SSH
  • 符合以下标准的操作系统:
    • 64 位 Ubuntu 10.04 LTS 或 12.04 LTS
    • 红帽企业版 Linux 5 或 6
    • CentOS 5 或 6
    • 甲骨文企业版 Linux 5
    • 企业服务器 11 (SP1 或拉索)
    • Debian 6.0

安装步骤如下:

  1. 下载并运行 Cloudera manager 安装程序:要初始化 Cloudera manager 安装过程，我们需要首先从 Cloudera 网站的下载部分下载cloudera-manager-installer.bin文件。之后，将其存储在集群中，以便所有节点都可以访问它。允许用户拥有cloudera-manager-installer.bin的执行权限。运行以下命令开始执行。

    $ sudo ./cloudera-manager-installer.bin

  2. 阅读 Cloudera 管理器自述文件，然后点击下一步。

  3. 启动 Cloudera 管理器管理控制台:Cloudera 管理器管理控制台允许您使用 Cloudera 管理器在集群上安装、管理和监控 Hadoop。接受 Cloudera 服务提供商的许可后，您需要通过在地址栏中输入http://localhost:7180来遍历您的本地网络浏览器。您也可以使用以下任何浏览器:

    • Firefox 11 或更高版本
    • 谷歌 Chrome
    • 微软公司出品的 web 浏览器
    • 旅行队

  4. 使用用户名和密码均为admin的默认凭据登录到 Cloudera 管理器控制台。以后你可以根据自己的选择改变它。

  5. 使用 Cloudera 管理器通过浏览器自动安装和配置 CDH3:这一步将把 Cloudera 所需的大部分【Cloudera Hadoop 包安装到您的机器上。步骤如下:

    1. 如果您选择了完整版本的软件，请安装并验证您的 Cloudera manager 许可证密钥文件。
    2. 为您的 CDH 群集安装指定主机名或 IP 地址范围。
    3. 使用 SSH 连接到每台主机。
    4. 在每个集群主机上安装 Java 开发工具包 ( JDK )(如果尚未安装)、Cloudera 管理器代理以及 CDH3 或 CDH4。
    5. 在每个节点上配置 Hadoop，并启动 Hadoop 服务。

  6. 运行向导并使用 Cloudera 管理器后，您应该尽快更改默认管理员密码。要更改管理员密码，请按照下列步骤操作:

    1. 单击带有齿轮符号的图标，显示管理页面。
    2. 打开密码标签。
    3. 输入两次新密码，然后点击更新。

  7. Test the Cloudera Hadoop installation: You can check the Cloudera manager installation on your cluster by logging into the Cloudera manager admin console and by clicking on the Services tab. You should see something like the following screenshot:

    Installing Cloudera Hadoop on Ubuntu

    Cloudera 管理器管理控制台

  8. You can also click on each service to see more detailed information. For example, if you click on the hdfs1 link, you might see something like the following screenshot:

    Installing Cloudera Hadoop on Ubuntu

    Cloudera 管理器管理控制台—HDFS 服务

    类型

    要避免这些安装步骤，请使用带有 Amazon Elastic MapReduce 和 MapReduce 的预配置 Hadoop 实例。

    如果你想在视窗系统上使用 Hadoop，试试霍顿工程公司的 HDP 工具。这是 Hadoop 100%开源的企业级分布。您可以在http://hortonworks.com/download/下载 HDP 工具。

了解 Hadoop 特性

Hadoop 是专门为两个核心概念设计的:HDFS 和 MapReduce。两者都与分布式计算有关。MapReduce 被认为是 Hadoop 的核心，它对分布式数据执行并行处理。

让我们看看关于 Hadoop 特性的更多细节:

  • HDFS
  • MapReduce

了解 HDFS

HDFS 是 Hadoop 自己的机架感知文件系统，这是 Hadoop 基于 UNIX 的数据存储层。HDFS 源于谷歌文件系统的概念。Hadoop 的一个重要特征是跨许多(数千)主机对数据和计算进行分区，并在接近其数据的情况下并行执行应用计算。在 HDFS，数据文件作为数据块序列在集群中复制。Hadoop 集群通过简单地添加商用服务器来扩展计算容量、存储容量和输入/输出带宽。可以通过许多不同的方式从应用访问 HDFS。HDFS 本地提供了一个 Java 应用编程接口供应用使用。

雅虎的 Hadoop 集群！跨越 40，000 台服务器并存储 40pb 的应用数据，最大的 Hadoop 集群为 4，000 台服务器。此外，全球还有 100 家其他组织使用 Hadoop。

了解 HDFS 的特点

让我们现在来看看 HDFS 的特点:

  • 容错
  • 使用商用硬件运行
  • 能够处理大型数据集
  • 主从范式
  • 只写一次文件访问

理解 MapReduce

MapReduce 是一个编程模型，用于处理分布在大型集群上的大型数据集。MapReduce 是 Hadoop 的核心。它的编程范例允许在配置了 Hadoop 集群的数千台服务器上执行海量数据处理。这是来源于谷歌 MapReduce。

Hadoop MapReduce 是一个用于轻松编写应用的软件框架，它以可靠、容错的方式在大型集群(数千个节点)的商用硬件上并行处理大量数据(多万亿字节数据集)。这个 MapReduce 范例分为两个阶段，Map 和 Reduce，主要处理数据的键和值对。映射和缩减任务在集群中顺序运行；映射阶段的输出成为减少阶段的输入。这些阶段解释如下:

  • 地图阶段:一旦被分割，数据集被分配给任务跟踪器来执行地图阶段。数据功能操作将在数据上执行，发出映射的键和值对作为映射阶段的输出。
  • 缩减阶段:然后主节点收集所有子问题的答案，并以某种方式组合形成输出；它最初试图解决的问题的答案。

并行计算的五个常见步骤如下:

  1. 准备Map()输入:这将逐行获取输入数据，并每行发出键值对，或者我们可以根据需要显式更改。

    • 地图输入:列表(k1，v1)

  2. 运行用户提供的Map()代码

    • 地图输出:列表(k2，v2)

  3. 将贴图输出混洗到缩小处理器。此外，洗牌相似的关键点(分组)并输入到相同的减速器。

  4. 运行用户提供的Reduce()代码:这个阶段将运行开发者设计的自定义 reducer 代码，在混洗的数据上运行，并发出键和值。

    • 减少输入:(k2，list(v2))
    • 减少输出:(k3，v3)

  5. Produce the final output: Finally, the master node collects all reducer output and combines and writes them in a text file.

    类型

    在谷歌文件系统上查看的参考链接可以在http://research.google.com/archive/gfs.html找到，谷歌地图缩减可以在http://research.google.com/archive/mapreduce.html找到。

学习 HDFS 和 MapReduce 架构

由于 HDFS 和 MapReduce 被认为是 Hadoop 框架的两个主要特性，我们将重点关注它们。那么，让我们首先从 HDFS 开始。

了解 HDFS 建筑

HDFS 可以呈现为主/从架构。HDFS 主机被命名为名称节点，而从机被命名为数据节点。名称节点是一个服务器管理文件系统名称空间，并调整客户端对文件的访问(打开、关闭、重命名等)。它将输入数据分成块，并宣布哪个数据块将存储在哪个数据节点中。数据节点是一个从属机器，它存储分区数据集的副本，并在请求到来时提供数据。它还执行块创建和删除。

HDFS 的内部机制将文件分成一个或多个块；这些块存储在一组数据节点中。在复制因素三的正常情况下，HDFS 策略是将第一个拷贝放在本地节点上，第二个拷贝放在具有不同节点的本地机架上，第三个拷贝放在具有不同节点的不同机架中。由于 HDFS 被设计为支持大文件，HDFS 块大小被定义为 64 MB。如果需要，这可以增加。

了解 HDFS 成分

HDFS 采用主从架构管理，包括以下组件:

  • 命名节点:这是 HDFS 体系的主宰。它维护目录、文件，并管理数据节点上存在的数据块。
  • 数据节点:这些是从机，部署在每台机器上并提供实际存储。他们负责为客户端提供读写数据请求。
  • 辅助名称节点:负责执行周期性检查点。因此，如果名称节点在任何时候出现故障，可以用由辅助名称节点检查点存储的快照映像替换它。

了解 MapReduce 架构

MapReduce 也是通过主从架构实现的。经典 MapReduce 包含作业提交、作业初始化、任务分配、任务执行、进度和状态更新、作业完成相关活动，主要由 JobTracker 节点管理，TaskTracker 执行。客户端应用向作业跟踪器提交作业。然后在集群中划分输入。然后，作业跟踪器计算要处理的映射和减速器的数量。它命令任务跟踪器开始执行作业。现在，任务跟踪器将资源复制到本地机器，并启动 JVM 来映射和减少数据上的程序。与此同时，任务跟踪器定期向作业跟踪器发送更新，这可以被视为有助于更新作业标识、作业状态和资源使用的心跳。

理解 MapReduce 组件

MapReduce 是用主从架构管理的，包含以下组件:

  • 作业跟踪器:这个是 MapReduce 系统的主节点，管理集群中的作业和资源(TaskTrackers)。作业跟踪器试图将每个映射安排得尽可能接近任务跟踪器上正在处理的实际数据，任务跟踪器运行在与底层块相同的数据节点上。
  • 任务跟踪器:这些是部署在每台机器上的从机。他们负责按照作业跟踪器的指示运行地图和减少任务。

通过剧情了解 HDFS 和 MapReduce 架构

在此图中，包含了 HDFS 和 MapReduce 主组件和从组件，其中 NameNode 和 DataNode 来自 HDFS，JobTracker 和 TaskTracker 来自 MapReduce 范例。

由主候选对象和从候选对象组成的两种范例都有自己特定的责任来处理 MapReduce 和 HDFS 操作。在下一个图中，有一个包含两个部分的图:前一个是 MapReduce 图层，后一个是 HDFS 图层。

Understanding the HDFS and MapReduce architecture by plot

HDFS 和 MapReduce 架构

Hadoop 是一个顶级的 Apache 项目，是一个非常复杂的 Java 框架。为了避免技术上的复杂，Hadoop 社区开发了许多 Java 框架，为 Hadoop 的特性增加了额外的价值。它们被视为 Hadoop 子项目。在这里，我们将讨论几个 Hadoop 组件，它们可以被认为是 HDFS 或 MapReduce 的抽象。

了解 Hadoop 子项目

Mahout 是一个流行的数据挖掘库。它采用最流行的数据挖掘可扩展机器学习算法来执行聚类、分类、回归和统计建模，以准备智能应用。此外，它是一个可扩展的机器学习库。

Apache Mahout 是根据商业友好的 Apache 软件许可证分发的。Apache Mahout 的目标是建立一个充满活力、响应迅速和多样化的社区，不仅促进对项目本身的讨论，也促进对潜在用例的讨论。

以下是一些使用 Mahout 的公司:

  • 亚马逊:这是一个提供个性化推荐的购物门户

  • AOL :这是一个购物推荐的购物入口

  • Drupal :这是一个使用 Mahout 的 PHP 内容管理系统，用于提供基于开源内容的推荐

  • iOffer :这是一个购物门户，利用 Mahout 的频繁模式集挖掘和协同过滤向用户推荐商品

  • LucidWorks 大数据:这是一家受欢迎的分析公司，它使用 Mahout 进行聚类、重复文档检测、阶段提取和分类

  • Radoop :这为大数据分析提供了一个拖放界面，包括 Mahout 聚类和分类算法

  • Twitter :这是一个社交网站，使用 Mahout 的潜在 Dirichlet 分配 ( LDA )实现进行用户兴趣建模，在 GitHub 上维护一个 Mahout 的分叉。

  • Yahoo!: This is the world's most popular web service provider, which uses Mahout's Frequent Pattern Set Mining for Yahoo! Mail

    类型

    Hadoop 生态系统的参考链接可以在http://www.revelytix.com/?q=content/hadoop-ecosystem找到。

Apache HBase 是一个面向 Hadoop 的分布式大数据存储。这允许对大数据进行随机、实时的读/写访问。这是受谷歌 BigTable 启发后创新的面向列的数据存储模型。

以下是使用 HBase 的公司:

  • 雅虎！:这是全球最受欢迎的近乎重复文档检测网络服务提供商

  • Twitter :这是一个用于版本控制存储和检索的社交网站

  • Mahalo :这是一个类似内容推荐的知识共享服务

  • NING :这是一家提供实时分析和报告的社交网络服务提供商

  • StumbleUpon :这是一个通用的个性化推荐系统，实时数据存储，数据分析平台

  • Veoh: This is an online multimedia content sharing platform for user profiling system

    类型

    谷歌大数据，结构化数据分布式存储系统，参考链接http://research.google.com/archive/bigtable.html。

Hive 是脸书开发的基于 Hadoop 的类数据仓库框架。它允许用户用类似 SQL 的语言发出查询，比如高度抽象为 Hadoop MapReduce 的 HiveQL。这允许没有 MapReduce 经验的 SQL 程序员使用仓库，并使其更容易与业务智能和可视化工具集成，以进行实时查询处理。

Pig 是一个基于 Hadoop 的开源平台，通过自己的类似 SQL 的语言:Pig Latin 来分析大规模数据集。这为大量复杂的数据并行计算提供了一个简单的操作和编程接口。这也更容易开发；它更加优化和可扩展。ApachePIG 已经被雅虎开发出来了！。目前，雅虎！和推特是小 PIG 的主要用户。

对于开发人员来说，直接使用 Java APIs 可能会比较繁琐或者容易出错，同时也限制了 Java 程序员使用 Hadoop 编程的灵活性。因此，Hadoop 提供了两种解决方案，使 Hadoop 使用 MapReduce 进行数据集管理和数据集分析的编程变得更加容易——这两种解决方案是 Pig 和 Hive，它们总是令人困惑。

Apache Sqoop 提供 Hadoop 数据处理平台，关系数据库、数据仓库等非关系数据库以全新的方式快速传输大量数据。Apache Sqoop 是一个双向数据工具，用于将数据从关系数据库导入到 Hadoop HDFS，并将数据从 HDFS 导出到关系数据库。

它与大多数现代关系数据库(如 MySQL、PostgreSQL、Oracle、微软 SQL Server 和 IBM DB2)以及企业数据仓库一起工作。Sqoop 扩展 API 提供了一种为数据库系统创建新连接器的方法。此外，Sqoop 源代码提供了一些流行的数据库连接器。为了执行这个操作，Sqoop 首先用一些数据库模式创建和转换的逻辑将数据转换成 Hadoop MapReduce。

Apache Zookeeper 也是一个 Hadoop 子项目，用于管理 Hadoop、Hive、Pig、HBase、Solr 等项目。Zookeeper 是一个开源的分布式应用协调服务，它是用 Fast Paxos 基于算法的同步以及分布式应用的维护等配置和命名服务设计的。在编程中，Zookeeper 设计是一种非常简单的数据模型风格，很像系统目录树结构。

Zookeeper 分为两部分:服务器和客户端。对于 Zookeeper 服务器集群，只有一个服务器充当领导者，接受并协调所有权限。其余的服务器是主服务器的只读副本。如果领导服务器关闭，任何其他服务器都可以开始处理所有请求。动物园管理员客户端连接到动物园管理员服务上的服务器。客户端发送请求，接收响应，访问观察器事件，并通过与服务器的 TCP 连接发送心跳。

对于分布式应用的高性能协调服务，Zookeeper 是一个集中式服务，用于维护配置信息、命名以及提供分布式同步和组服务。分布式应用以某种形式使用所有这些类型的服务。每次实现它们时，都有大量的工作要做，以修复不可避免的错误和竞争条件。部署应用时，这些服务会导致管理复杂性。

Apache Solr 是来自 Apache 许可证项目的开源企业搜索平台。Apache Solr 具有高度的可扩展性，支持分布式搜索和索引复制引擎。这允许用强大的文本搜索、分面搜索、实时索引、动态聚类、数据库集成和丰富的文档处理来构建 web 应用。

Apache Solr 是用 Java 编写的，它作为一个独立的服务器运行，通过类似 REST 的 HTTP/XML 和 JSON APIs 提供搜索结果。因此，这个 Solr 服务器可以很容易地与用其他编程语言编写的应用集成在一起。由于所有这些功能，这个搜索服务器被网飞、美国在线、CNET 和 Zappos 使用。

安巴里 是非常专属于霍顿工厂的。Apache Ambari 是一个基于网络的工具，支持 Apache Hadoop 集群的供应、管理和监控。Ambari 处理大部分 Hadoop 组件，包括 HDFS、MapReduce、Hive、Pig、HBase、Zookeeper、Sqoop 和 HCatlog 作为集中管理。

此外，安巴里能够通过 Hadoop 集群安装基于 Kerberos 身份验证协议的安全性。此外，它还为用户提供基于角色的用户身份验证、授权和审核功能，以管理集成的 LDAP 和活动目录。

总结

在本章中，我们学习了什么是 R、Hadoop 及其功能，以及如何安装它们，然后继续使用 R 和 Hadoop 分析数据集。在下一章中，我们将学习什么是 MapReduce，以及如何使用 Apache Hadoop 开发 MapReduce 程序。

二、编写 Hadoop MapReduce 程序

在前一章中，我们学习了如何设置 R 和 Hadoop 开发环境。因为我们对执行大数据分析感兴趣，所以我们需要学习 Hadoop 来使用 Hadoop MapReduce 执行操作。在本章中，我们将讨论什么是 MapReduce，为什么有必要，如何通过 Apache Hadoop 开发 MapReduce 程序，等等。

在本章中，我们将介绍:

  • 了解 MapReduce 的基础知识
  • 介绍 Hadoop MapReduce
  • 了解 Hadoop MapReduce 基础知识
  • 编写 Hadoop MapReduce 示例
  • 理解几种可能的 MapReduce 定义来解决业务问题
  • 学习用 R 写 Hadoop MapReduce 的不同方法

了解 MapReduce 的基础知识

如果一个人没有集群或者使用消息传递接口 ( MPI ) ，理解 MapReduce 的基础可能是一个长期的解决方案。然而，一个更现实的用例是当数据不适合一个磁盘，但是适合一个分布式文件系统 ( DFS )或者已经存在于 Hadoop 相关软件上。

此外，MapReduce 是一种以分布式方式工作的编程模型，但它并不是唯一这样做的模型。描述其他编程模型可能很有启发性，例如 MPI 和批量同步并行 ( BSP )。用 R 等工具和几种机器学习技术处理大数据需要高配置的机器，但这不是永久的解决方案。因此，分布式处理是处理这些数据的关键。这种分布式计算可以用 MapReduce 编程模型来实现。

MapReduce 是回答大数据问题的工具。从逻辑上讲，要处理数据，我们需要并行处理，这意味着在大计算上进行处理；它可以通过计算机集群或增加机器的配置来获得。使用计算机集群是处理大容量数据的理想方式。

在我们讨论更多关于并行处理的 MapReduce 之前，我们将讨论谷歌 MapReduce 研究和 2004 年由 Jeffrey Dean 和 Sanjay Ghemawat 撰写的白皮书。他们引入了 MapReduce 作为大型集群上的简化数据处理软件。MapReduce 实现运行在拥有商用硬件的大型集群上。这个数据处理平台更容易让程序员进行各种操作。该系统处理输入数据，在计算机网络上分发数据，并行处理数据，最后将其输出合并成一个文件，供以后聚合。这在成本方面非常有帮助，对于处理集群中的大型数据集也是一个省时的系统。此外，它将有效地利用计算机资源对大量数据进行分析。谷歌已经获得了 MapReduce 的专利。

对于 MapReduce，程序员只需要将应用设计/迁移到两个阶段:Map 和 Reduce。他们只需设计用于处理键值对的 Map 函数来生成一组中间键值对，并设计 Reduce 函数来合并所有中间键。“地图”和“缩小”功能都维护地图缩小工作流。完成后或地图输出可用时，减少功能将开始执行代码。

它们的执行顺序如下:

Understanding the basics of MapReduce

MapReduce 假设地图是独立的，并将并行执行它们。MapReduce 算法的关键方面是，如果每个 Map 和 Reduce 都独立于网络中所有其他正在进行的 Map 和 Reduce，则操作将在不同的键和数据列表上并行运行。

分布式文件系统将数据的多个副本分布在不同的机器上。这提供了可靠性和容错能力。如果有一个文件副本的机器崩溃，将从另一个复制的数据源提供相同的数据。

MapReduce 守护程序的主节点将负责 MapReduce 作业的所有职责，例如作业的执行、Mappers、Reducers、Combiners 和 Partitioners 的调度、单个作业任务的成功和失败的监控，以及最终批处理作业的完成。

Apache Hadoop 通过在 Hadoop 分布式文件系统上存储的数据附近的服务器上运行 Hadoop MapReduce 作业，以并行方式处理分布式数据。

使用 MapReduce 的公司包括:

  • 亚马逊:这是一家面向大数据分析的在线电商和云 web 服务提供商
  • 易贝:这是一个通过描述查找文章的电商门户
  • 谷歌:这是一个网络搜索引擎，用于查找与特定主题相关的网页
  • LinkedIn :这是一个专业的大数据存储和生成个性化推荐的社交网站
  • trobit:这是一个垂直搜索引擎，用来寻找符合给定描述的工作
  • 推特:这是一个寻找消息的社交网站

除此之外，还有许多其他品牌正在使用 Hadoop 进行大数据分析。

介绍 Hadoop MapReduce

基本上，MapReduce 模型可以用多种语言实现，但除此之外，Hadoop MapReduce 是一个流行的 Java 框架，适合容易编写的应用。它以可靠和容错的方式在大型商用硬件集群(数千个节点)上并行处理大量数据(多字节数据集)。这个 MapReduce 范例分为两个阶段，Map 和 Reduce，主要处理数据的键值对。地图和减少任务在集群中顺序运行，地图阶段的输出成为减少阶段的输入。

不能更新 MapReduce 中的所有数据输入元素。如果映射任务的输入(key, value)对发生变化，则不会反映在输入文件中。映射器输出将通过管道传输到适当的缩减器，该缩减器以键属性作为输入进行分组。在 Hadoop MapReduce 算法和 Hadoop 集群的帮助下，这个顺序数据过程将以并行方式进行。

MapReduce 程序将列表格式的输入数据集转换成也是列表格式的输出数据。这个逻辑列表转换过程在映射和缩减阶段通常会重复两次。我们也可以通过固定映射器和缩减器的数量来处理这些重复。在下一节中，将基于旧的 MapReduce 应用编程接口描述 MapReduce 概念。

列出 Hadoop MapReduce 实体

以下是负责对大数据执行分析的 Hadoop 组件:

  • 客户端:这个初始化作业
  • 作业跟踪器:这个监控作业
  • 任务跟踪器:这个执行任务
  • HDFS :此存储输入输出数据

了解 Hadoop MapReduce 场景

Hadoop MapReduce 数据处理的四个主要阶段如下:

  • 将数据加载到 HDFS
  • 地图阶段的执行
  • 洗牌和排序
  • 减少阶段的执行

将数据加载到 HDFS

输入的数据集需要上传到 Hadoop 目录的中，以便 MapReduce 节点使用。然后， Hadoop 分布式文件系统 ( HDFS )将输入数据集划分为数据分割，并通过考虑容错的复制因素将其存储到集群中的数据节点。所有数据分割将由任务跟踪器以并行方式处理地图和减少任务。

此外，还有一些使用 Hadoop 组件在 HDFS 获取数据集的替代方法:

  • Sqoop :这是一个开源工具，旨在高效地在 Apache Hadoop 和结构化关系数据库之间传输大量数据。假设您的应用已经配置了 MySQL 数据库，并且您希望使用相同的数据来执行数据分析，建议使用 Sqoop 将数据集导入 HDFS。此外，在数据分析过程完成后，输出可以导出到 MySQL 数据库。
  • Flume :这个是一个分布式的、可靠的、可用的服务，用于高效地收集、聚合和移动大量的日志数据到 HDFS。Flume 能够读取大多数来源的数据，例如日志文件、sys 日志和 Unix 进程的标准输出。

使用前面的数据收集和移动框架可以使数据传输过程对于数据分析的 MapReduce 应用非常容易。

执行地图阶段

执行客户端应用会启动 Hadoop MapReduce 进程。然后，映射阶段复制作业资源(未归档的类文件)并将其存储到 HDFS，并请求作业跟踪器执行该作业。作业跟踪器初始化作业，检索输入，分割信息，并为每个作业创建一个映射任务。

作业跟踪器将调用任务跟踪器在分配的输入数据子集上运行映射任务。映射任务将该输入分割数据读取为提供给映射器方法的输入(key, value)对，然后映射器方法产生中间的(key, value)对。每个输入(key, value)对至少有一个输出。

Executing the Map phase

映射输入列表的单个元素

生成(键、值)对的列表，使得键属性将被重复多次。因此，它的关键属性将在 Reduce 中重新用于聚合 MapReduce 中的值。就格式而言，Mapper 输出格式值和 Reducer 输入值必须相同。

完成此映射操作后，任务跟踪器将把结果保存在其缓冲存储和本地磁盘空间中(如果输出数据大小超过阈值)。

例如，假设我们有一个Map函数，将输入文本转换为小写。这将把输入字符串列表转换成小写字符串列表。

类型

键和值:在 MapReduce 中，每个值都有其标识符，该标识符被认为是键。映射器接收的键值对取决于作业配置文件中指定的输入数据类型。

洗牌和排序

为了优化 MapReduce 程序，这个中间阶段非常重要。

一旦从映射阶段输出的映射器可用，这个中间阶段将被自动调用。映射阶段完成后，仅当分区器存在时，映射器端的分区器才会对所有发出的中间(键、值)对进行分区。分区器的输出将根据映射器端的键属性进行排序。排序操作的输出存储在映射器节点“任务跟踪器”的缓冲存储器中。

组合器通常是减速器本身。所以通过压缩，不是 Gzip 或者类似的压缩，而是地图输出数据的节点上的 Reducer。然后，合并器返回的数据被混洗并发送到精简节点。为了加快映射器输出到任务跟踪器的减速器插槽的数据传输，您需要使用Combiner功能压缩该输出。默认情况下，映射器输出将存储到缓冲内存中，如果输出大小大于阈值，它将存储到本地磁盘中。该输出数据将通过 超文本传输协议 ( HTTP )获得。

减少阶段执行

一旦映射器输出可用，减速器节点中的任务跟踪器将检索可用的分区映射的输出数据，它们将被组合在一起并合并成一个大文件，然后用Reducer方法将其分配给一个进程。最后，这将在数据提供给Reducer方法之前进行整理。

Reducer方法从输入(key, list (value))接收输入值列表，并基于自定义逻辑对它们进行聚合，并产生输出(key, value)对。

Reducing phase execution

将输入值减少到一个总值作为输出

减少阶段的Reducer方法的输出将按照 MapReduce 作业配置类指定的格式直接写入 HDFS。

了解 MapReduce 的局限性

让我们看看 Hadoop MapReduce 的一些局限性:

  • 众所周知，MapReduce 框架很难用于不那么简单的转换逻辑，例如实时流、图形处理和消息传递。
  • 与使用索引数据创建的数据库相比，分布式、未索引数据的数据查询效率较低。但是，如果生成了数据的索引，则需要在删除或添加数据时对其进行维护。
  • 我们不能将缩减任务并行化为地图任务来减少整体处理时间，因为在地图任务的输出可用之前，缩减任务不会启动。(减速器的输入完全依赖于映射器的输出。)此外，我们无法控制地图和缩小任务的执行顺序。但是有时，基于应用逻辑，当数据收集在地图任务完成后立即开始时，我们肯定可以在实例上为缩减任务配置一个缓慢的开始。
  • 长期运行的缩减任务无法完成，因为它们的资源利用率很低，如果缩减任务花费太多时间来完成并且失败，或者如果没有其他可用的缩减槽来重新计划它(这可以通过 Yarn 来解决)。

了解 Hadoop 解决问题的能力

因为这本书是面向分析师的，所以提供分析性的例子可能是相关的；例如，如果读者有一个类似于前面描述的问题，Hadoop 可能会有用。Hadoop 不是所有大数据问题的通用解决方案；当大数据需要分成小块并分布在需要并行处理的服务器上时，这是一种很好的技术。这节省了对庞大数据集执行分析的时间和成本。

如果我们能够为问题设计地图和减少阶段，就有可能用地图减少来解决。通常，Hadoop 提供计算能力来处理不适合机器内存的数据。(R 用户在处理大数据时大多发现错误消息，看到如下消息:无法分配大小为 2.5 GB 的向量。)

了解 Hadoop 编程中使用的不同 Java 概念

有一些经典的 Java 概念让 Hadoop 更具交互性。它们是如下:

  • 远程过程调用:这是一种进程间通信，允许计算机程序在另一个地址空间(通常在共享网络上的另一台计算机上)执行一个子例程或过程，而无需程序员为这种远程交互明确编码。也就是说，无论子程序是在执行程序的本地还是远程，程序员编写的代码本质上都是相同的。
  • 序列化/反序列化:有了序列化，一个 Java 虚拟机 ( JVM )就可以把对象的状态写出到某个流中，这样我们基本上就可以读取所有的成员，把把它们的状态写出到一个流、磁盘等等。默认机制是二进制格式，因此比文本格式更紧凑。通过这种方式，机器可以通过网络发送数据。反序列化则相反，用于通过网络接收数据对象。
  • Java 泛型:这个允许一个类型或方法对各种类型的对象进行操作，同时提供编译时类型安全，使 Java 成为一种完全静态类型化的语言。
  • Java 集合:这个框架是一组类和接口，用单个 Java 对象处理各种类型的数据集合。
  • Java 并发:这个是为了支持并发编程而设计的，所有的执行都发生在线程的上下文中。它主要用于将计算进程实现为单个操作系统进程中的一组线程。
  • 普通旧 Java 对象 ( POJO ):这些其实是普通的 JavaBeans。POJO 暂时用于设置为以及来检索数据对象的值。

了解 Hadoop MapReduce 基础知识

为了正确理解 Hadoop MapReduce 的基本原理，我们将:

  • 理解 MapReduce 对象
  • 了解如何在 MapReduce 中决定地图的数量
  • 了解如何在 MapReduce 中决定减少的数量
  • 理解 MapReduce 数据流
  • 仔细看看 Hadoop MapReduce 术语

理解 MapReduce 对象

正如我们所知， Hadoop 中的 MapReduce 操作主要由三个对象来执行:Mapper、Reduce 和 Driver。

  • 映射器:这是为 MapReduce 的 Map 阶段设计的，它通过携带输入文件并将其拆分成若干块来启动 MapReduce 操作。对于每个片段，它将发出一个键值数据对作为输出值。
  • 减速器:这个是为 MapReduce 作业的 Reduce 阶段设计的；它从 Mapper 输出中接受基于键的分组数据，通过聚合逻辑对其进行缩减，并为该组值发出(key, value)对。
  • 驱动程序:这个是驱动 MapReduce 进程的主文件。它在从客户端应用获得带有参数的请求后开始执行 MapReduce 任务。驱动程序文件负责构建作业的配置，并将其提交给 Hadoop 集群。驱动程序代码将包含从命令行接受参数的main()方法。该程序将接受 Hadoop MapReduce 作业的输入和输出目录。驱动程序是定义作业配置详细信息的主要文件，如作业名称、作业输入格式、作业输出格式以及映射器、组合器、分区器和缩减器类。MapReduce 通过调用 Driver 类的这个main()函数进行初始化。

不是每一个问题都可以用单个 Map 和单个 Reduce 程序解决，但是用单个 Map 和单个 Reduce 任务解决不了的就更少了。有时，还需要设计具有多个地图和缩小任务的地图缩小作业。当我们需要在单个作业中一起执行数据操作时，例如数据提取、数据清理和数据合并，我们可以设计这种类型的作业。通过为单个作业编写多个映射器和缩减器任务，可以解决许多问题。在多个映射和缩减任务的情况下，将顺序调用的映射缩减步骤是映射 1 后接缩减 1，映射 2 后接缩减 2，依此类推。

当我们需要编写一个具有多个 Map 和 Reduce 任务的 MapReduce 作业时，我们必须编写多个 MapReduce 应用驱动程序来顺序运行它们。

在提交地图缩减作业时，我们可以提供许多地图任务，并将根据映射器输入的输出和 Hadoop 集群容量创建许多缩减器。此外，请注意，设置映射器和缩减器的数量不是强制性的。

决定 MapReduce 中地图的数量

地图的号是，通常由输入数据的大小和数据分割块的大小来定义，数据分割块的大小由 HDFS 文件/数据分割的大小来计算。因此，如果我们有一个 5 TB 的 HDFS 数据文件和一个 128 MB 的块大小，文件中将有 40，960 个映射。但是有时，由于推测性执行，创建的映射器的数量会超过这个计数。当输入是一个文件时，这是正确的，尽管它完全依赖于InputFormat类。

在 Hadoop MapReduce 处理中，当分配的映射器或缩减器需要很长时间才能完成时，作业的结果会有延迟。如果您想避免这种情况，Hadoop 中的推测执行可以在不同的节点上运行同一个 Map 或 Reduce 任务的多个副本，并且可以使用第一个完成的节点的结果。从带有setNumMapTasks(int)方法的 Hadoop API 中，我们可以了解 Mappers 的数量。

决定 MapReduce 中的 Reduce 数量

减速器的数量是根据映射器的输入创建的。但是，如果在 MapReduce 中硬编码 Reduce 的数量，集群中有多少节点并不重要。它将按照配置中的指定执行。

此外，我们可以在运行时使用命令提示符-D mapred.reduce.tasks中的 MapReduce 命令设置减速器的数量，以及您想要的数量。可通过conf.setNumReduceTasks(int)编程设置。

理解 MapReduce 数据流

现在我们已经看到了使一个基本的 MapReduce 作业成为可能的组件，我们将在更高的层次上区分一切是如何协同工作的。从下图中，我们将理解 Hadoop 集群中多个节点的 MapReduce 数据流:

Understanding MapReduce dataflow

MapReduce 数据流

Hadoop MapReduce 可用的两个应用编程接口是:新的(Hadoop 1.x 和 2.x)和旧的 Hadoop (0.20)。Yarn 是下一代 Hadoop MapReduce 和新的 Apache Hadoop 子项目，已为 Hadoop 资源管理发布。

Hadoop 数据处理包括几项任务，有助于实现输入数据集的最终输出。这些任务如下:

  1. 在 HDFS 预加载数据。
  2. 通过调用驱动程序运行 MapReduce。
  3. 映射器读取输入数据，这将导致映射器自定义逻辑的数据执行分离，并生成中间键值对
  4. 执行合并器和洗牌阶段，以优化整个 Hadoop MapReduce 过程。
  5. 对中间键值对进行排序并将其提供给缩减阶段。然后执行减少阶段。Reducer 获取这些分区的键值对，并基于 Reducer 逻辑对它们进行聚合。
  6. 最终输出数据存储在 HDFS。

在这里，可以为多个数据操作定义映射和缩减任务，如下所示:

  • 数据析取
  • 数据加载
  • 数据分段
  • 数据清理
  • 数据转换
  • 数据集成

我们将在本章的下一部分更详细地探讨 MapReduce 任务。

仔细看看 Hadoop MapReduce 术语

在这一部分，我们将看到关于 Hadoop MapReduce 数据流的更多细节，包括几个 MapReduce 术语及其 Java 类细节。在上一节的 MapReduce 数据流图中，多个节点通过网络连接，使用 Hadoop 设置执行分布式处理。地图和缩减阶段的后续属性对获得最终输出起着重要作用。

地图阶段的属性如下:

  • InputFiles 术语是指已创建/提取用于商业分析的输入原始数据集，这些数据集已存储在 HDFS。这些输入文件非常大，有几种类型。
  • InputFormat 是一个 Java 类，通过获取每行偏移量的文本和内容来处理输入文件。它定义了如何分割和读取输入数据文件。我们可以设置与地图和缩小阶段相关的输入格式的几种输入类型，如TextInputFormat、KeyValueInputFormat和SequenceFileInputFormat。
  • InputSplits 类用于设置数据拆分的大小。
  • RecordReader 是一个 Java 类，它有几种方法通过在数据分割中迭代来检索键和值。此外，它还包括获取当前进度状态的其他方法。
  • 为地图阶段创建Mapper 实例。Mapper类接受输入(key, value)对(由 RecordReader 生成)，并通过在Map()方法中执行用户定义的代码来产生中间的(key, value)对。Map()方式主要取两个输入参数:键和值；剩下的是OutputCollector和Reporter. OutputCollector。他们将提供中间的键值对，以减少工作的阶段。报告程序定期向作业跟踪器提供当前作业的状态。作业跟踪器将在作业结束时聚合它们，以便以后检索。

减少阶段的属性如下:

  • 在完成映射阶段后，基于hash函数中的关键属性相似性考虑，对生成的中间(key, value)对进行划分。所以，每个地图任务可能会发出(key, value)对来划分；同一个键的所有值总是一起减少，而不考虑哪个映射器是它的原点。地图阶段完成后，地图缩减作业将自动完成这种分区和洗牌。没有必要单独给他们打电话。此外，我们可以根据 MapReduce 作业的要求显式覆盖它们的逻辑代码。
  • 在完成分区和洗牌之后，初始化缩减任务之前，Hadoop MapReduce 作业基于关键属性值对中间的(key, value)对进行排序。
  • Reduce实例是为减少阶段创建的。它是用户提供的执行减少任务的代码部分。Reducer类的一个Reduce()方法主要带两个参数，以及OutputCollector和Reporter，与Map()功能相同。它们是OutputCollector和Reporter对象。“映射”和“缩减”中的OutputCollector具有相同的功能，但是在“缩减”阶段，OutputCollector提供输出到下一个“映射”阶段(在多个“映射”和“缩减”作业组合的情况下)，或者根据需求将其报告为作业的最终输出。除此之外，Reporter定期向作业跟踪器报告正在运行的任务的当前状态。
  • 最后，在OutputFormat中，生成的输出(键、值)对被提供给OutputCollector参数，然后被写入由OutputFormat控制的OutputFiles。它控制地图缩减驱动程序中定义的OutputFiles格式的设置。格式将从TextOutputFormat、SequenceFileOutputFileFormat或NullOutputFormat中选择。
  • OutputFormat使用的工厂RecordWriter以适当的格式写入输出数据。
  • 输出文件是 MapReduce 作业完成后RecordWriter写入 HDFS 的输出数据。

为了高效地运行这个 MapReduce 作业，我们需要了解一些 Hadoop shell 命令来执行管理任务。请参考下表:

|

外壳命令

|

用法和代码示例

|
| --- | --- |
|

cat

| 要将源路径复制到stdout:

Hadoop fs -cat URI [URI …]

|
|

chmod

| 要更改文件的权限:

Hadoop fs -chmod [-R] <MODE[,MODE]... &#124; OCTALMODE> URI [URI …]

|
|

copyFromLocal

| 要将文件从本地存储复制到 HDFS:

Hadoop fs –copyFromLocal<localsrc> URI

|
|

copyToLocal

| 要将文件从 HDFS 复制到本地存储，请执行以下操作:

Hadoop fs -copyToLocal [-ignorecrc] [-crc] URI <localdst>

|
|

cp

| 要将文件从源位置复制到 HDFS 的目标位置，请执行以下操作:

Hadoop fs -cp URI [URI …] <dest>

|
|

du

| 要显示文件的总长度:

Hadoop fs -du URI [URI …]

|
|

dus

| 要显示文件长度的摘要:

Hadoop fs -dus<args>

|
|

get

| 要将文件复制到本地文件系统:

Hadoop fs -get [-ignorecrc] [-crc] <src><localdst>

|
|

ls

| 要列出 HDFS 当前目录中的所有文件:

Hadoop fs –ls<args>

|
|

mkdir

| 要在 HDFS 创建目录:

Hadoop fs –mkdir<paths>

|
|

lv

| 要将文件从源移动到目标:

Hadoop fs -mv URI [URI …] <dest>

|
|

rmr

| 要从当前目录中删除文件:

Hadoop fs -rmr URI [URI …]

|
|

setrep

| 要更改文件的复制因子:

Hadoop fs -setrep [-R] <path>

|
|

tail

| 将文件的最后一千字节显示到stdout:

Hadoop fs -tail [-f] URI

|

写一个 Hadoop MapReduce 的例子

现在，我们将通过学习一个非常常见且简单的字数示例来推进 MapReduce。这个例子的目标是计算每个单词在提供的文档中出现的次数。这些文档可以被认为是 MapReduce 文件的输入。

在这个例子中，我们已经有了一组文本文件——我们想要识别文件中存在的所有唯一单词的频率。我们将通过设计 Hadoop MapReduce 阶段来实现这一点。

在本节中，我们将看到更多关于使用 Hadoop MapReduce 的旧应用编程接口进行 Hadoop MapReduce 编程的信息。这里我们假设读者已经按照第 1 章、准备使用 R 和 Hadoop 中的描述设置了 Hadoop 环境。另外，请记住，我们不会使用 R 来计算单词；这里将只使用 Hadoop。

基本上，Hadoop MapReduce 有三个主要对象:映射器、缩减器和驱动程序。它们可以用三个 Java 类开发；它们是Map类、Reduce类和Driver类，其中Map类表示 Map 阶段，Reducer类表示 Reduce 阶段，Driver类表示用main()方法初始化 Hadoop MapReduce 程序的类。

在 Hadoop MapReduce 基础的上一节中，我们已经讨论了什么是映射器、减速器和驱动程序。现在，我们将学习如何定义它们，并用 Java 为它们编程。在接下来的章节中，我们将学习如何结合使用 R 和 Hadoop 做更多的事情。

类型

有许多语言和框架用于构建 MapReduce，但每种语言和框架都有不同的优势。有多种因素可以通过修改在 MapReduce 上提供高延迟。参考 Cloudera 在http://blog.cloudera.com/blog/2009/05/10-mapreduce-tips/发布的文章 10 MapReduce 提示 。

为了让 MapReduce 开发更容易，使用配置了 Maven 的 Eclipse ，支持旧的 MapReduce API。

了解运行 MapReduce 作业的步骤

让我们看看用 Hadoop 运行 MapReduce 作业的步骤:

  1. 在准备 Java 类的最初步骤中，我们需要您根据我们业务问题的定义开发一个 Hadoop MapReduce 程序。在这个的例子中，我们考虑了一个字数问题。所以，我们为 MapReduce 程序开发了三个 Java 类；它们是Map.java、Reduce.java和WordCount.java，用于计算单词在提供的文本文件中的出现频率。

    • Map.java:这是字数映射器的 Map 类。

      // Defining package of the class
package com.PACKT.chapter1;

// Importing java libraries 
import java.io.*;
importjava.util.*;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapred.*;

// Defining the Map class
public class Map extends MapReduceBase implements
         Mapper<LongWritable, 
                Text, 
                Text, 
                IntWritable>{

//Defining the map method – for processing the data with // problem specific logic
public void map(LongWritable key,
                Text value,
                OutputCollector<Text,
                IntWritable> output,
                Reporter reporter) 
                throws IOException {

// For breaking the string to tokens and convert them to lowercase
StringTokenizer st = new StringTokenizer(value.toString().toLowerCase());

// For every string tokens
while(st.hasMoreTokens()) {

// Emitting the (key,value) pair with value 1.
output.collect(new Text(st.nextToken()), 
               new IntWritable(1));
        }

    }

}

    • Reduce.java:这个是字数缩减器的缩减类。

      // Defining package of the class
package com.PACKT.chapter1;

// Importing java libraries
import java.io.*;
importjava.util.*;
import org.apache.hadoop.io.*;
importorg.apache.hadoop.mapred.*;

// Defining the Reduce class 
public class Reduce extends MapReduceBase implements
          Reducer<Text,
                  IntWritable,
                  Text,
                  IntWritable> {

// Defining the reduce method for aggregating the //generated output of Map phase
public void reduce(Text key,
                   Iterator<IntWritable> values,
                   OutputCollector<Text,IntWritable>
                   output, 
                   Reporter reporter) throws IOException {

// Setting initial counter value as 0
int count = 0;

// For every element with similar key attribute, increment its counter value by adding 1.
while(values.hasNext()) {
count += values.next().get();
        }

// Emitting the (key,value) pair
output.collect(key, new IntWritable(count));
    }
}

    • WordCount.java:这是 Hadoop MapReduce 驱动主文件中驱动的任务。

      //Defining package of the class
package com.PACKT.chapter1;

// Importing java libraries
import java.io.*;
importorg.apache.hadoop.fs.*;
import org.apache.hadoop.io.*;
importorg.apache.hadoop.mapred.*;
importorg.apache.hadoop.util.*;
importorg.apache.hadoop.conf.*;

//Defining wordcount class for job configuration 
  // information
public class WordCount extends Configured implements Tool{

publicint run(String[] args) throws IOException{
JobConfconf = new JobConf(WordCount.class);
conf.setJobName("wordcount");

//For defining the output key format
conf.setOutputKeyClass(Text.class);

//For defining the output value format
conf.setOutputValueClass(IntWritable.class);

// For defining the Mapper class implementation
conf.setMapperClass(Map.class);

// For defining the Reducer class implementation
conf.setReducerClass(Reduce.class);

// For defining the type of input format 
conf.setInputFormat(TextInputFormat.class);

// For defining the type of output format
conf.setOutputFormat(TextOutputFormat.class);

// For defining the command line argument sequence for // input dataset path
FileInputFormat.setInputPaths(conf, new Path(args[0]));

// For defining the command line argument sequence for // output dataset path
FileOutputFormat.setOutputPath(conf, new Path(args[1]));

// For submitting the configuration object
JobClient.runJob(conf);

return 0;
    }

// Defining the main() method to start the execution of // the MapReduce program
public static void main(String[] args) throws Exception {
  intexitCode = ToolRunner.run(new WordCount(), args);
  System.exit(exitCode); } }

  2. 编译 Java 类。

    // create a folder for storing the compiled classes
hduser@ubuntu:~/Desktop/PacktPub$ mkdir classes

// compile the java class files with classpath
hduser@ubuntu:~/Desktop/PacktPub$ javac -classpath /usr/local/hadoop/hadoop-core-1.1.0.jar:/usr/local/hadoop/lib/commons-cli-1.2.jar -d classes *.java

  3. 从编译的类中创建一个.jar文件。

    hduser@ubuntu:~/Desktop/PacktPub$ cd classes/

// create jar of developed java classes
hduser@ubuntu:~/Desktop/PacktPub/classes$ jar -cvf wordcount.jar com

  4. 启动 Hadoop 守护程序。

    // Go to Hadoop home Directory
hduser@ubuntu:~$ cd $HADOOP_HOME

// Start Hadoop Cluster
hduser@ubuntu:/usr/local/hadoop$ bin/start-all.sh

  5. 检查所有正在运行的守护程序。

    // Ensure all daemons are running properly 
hduser@ubuntu:/usr/local/hadoop$ jps

  6. 创建 HDFS 目录/wordcount/input/。

    // Create Hadoop directory for storing the input dataset
hduser@ubuntu:/usr/local/hadoop$ bin/Hadoop fs -mkdir /wordcount/input

  7. 提取要在字数统计示例中使用的输入数据集。由于我们需要通过字数统计示例来处理文本文件，因此我们将使用 Hadoop 发行版提供的文本文件(CHANGES.txt、LICENSE.txt、NOTICE.txt和README.txt)将其复制到 Hadoop 目录中。我们可以在这个 MapReduce 算法中使用来自互联网输入的其他文本数据集，而不是使用现成的文本文件。我们也可以从互联网上提取数据来处理它们，但是这里我们使用的是现成的输入文件。

  8. 将所有文本文件复制到 HDFS。

    // To copying the text files from machine's local
 // directory in to Hadoop directory

hduser@ubuntu:/usr/local/hadoop$ bin/hadoopfs -copyFromLocal $HADOOP_HOME/*.txt /wordcount/input/

  9. 使用以下命令运行 Hadoop MapReduce 作业:

    // Command for running the Hadoop job by specifying jar, main class, input directory and output directory.

hduser@ubuntu:/usr/local/hadoop$ bin/hadoop jar wordcount.jar com.PACKT.chapter1.WordCount /wordcount/input/ /wordcount/output/

  10. This is how the final output will look.

```r
// To read the generated output from HDFS directory

hduser@ubuntu:/usr/local/hadoop$ bin/hadoopfs -cat /wordcount/output/part-00000

```

### 类型

在 MapReduce 阶段，您需要监控作业和节点。使用以下内容监控网络浏览器中的 MapReduce 作业:

*   本地主机:50070:名称节点网络接口(适用于 HDFS)
*   `localhost:50030` : JobTracker Web 界面(针对 MapReduce 层)
*   `localhost:50060`:taskstracker Web 界面(针对 MapReduce 层)

学习监控和调试 Hadoop MapReduce 作业

在本节中，我们将学习如何在没有任何命令的情况下监控和调试 Hadoop MapReduce 作业。

这是使用 Hadoop MapReduce 管理用户界面最简单的方法之一。我们可以通过浏览器输入网址http://localhost:50030(作业跟踪器守护程序的网络用户界面)来访问它。这将显示 Hadoop MapReduce 作业的日志信息，如下图所示:

Learning to monitor and debug a Hadoop MapReduce job

映射/减少管理

在这里我们可以查看正在运行的作业的信息和状态，一个作业的 Map 和 Reduce 任务的状态，过去已完成的作业以及 Map 和 Reduce 任务失败的失败作业。此外，我们可以通过单击失败地图的超链接或失败作业的缩减任务来调试地图缩减作业。这将在作业运行时在标准输出上产生一条错误消息。

探索 HDFS 数据

在本节中，我们将看到如何在不运行任何 Bash 命令的情况下探索 HDFS 目录。名称节点守护程序的网络用户界面提供了这样的功能。我们只需要在http://localhost:50070找到它。

Exploring HDFS data

名称节点管理

该用户界面使我们能够获得集群摘要(内存状态)、名称节点日志以及集群中活节点和死节点的信息。此外，这允许我们探索为存储 Hadoop MapReduce 作业的输入和输出数据而创建的 Hadoop 目录。

理解几种可能的 MapReduce 定义来解决业务问题

到目前为止，我们已经了解了什么是 MapReduce 以及如何对其进行编码。现在，我们将看到一些用于业务分析的常见 MapReduce 问题定义。任何了解 Hadoop 的 MapReduce 的读者都可以通过修改字数的 MapReduce 示例来轻松编码和解决这些问题定义。主要的变化将是数据解析和数据操作背后的逻辑。主要工作将需要在数据收集、数据清理和数据存储方面。

  • 服务器 web 日志处理:通过这个 MapReduce 定义，我们可以进行 web 日志分析。web 服务器的日志提供了有关 web 请求的信息，如请求页面的 URL、日期、时间和协议。由此，我们可以从 web 服务器日志中识别出我们网站的峰值负载时间，并根据网站的流量对我们的 web 服务器配置进行缩放。因此，识别夜间无流量将有助于我们通过缩小服务器规模来节省资金。此外，还有许多业务案例可以通过 web 日志服务器分析来解决。
  • 带有网站统计的 Web 分析:网站统计可以提供更详细的关于访问者元数据的信息，例如来源、活动、访问者类型、访问者位置、搜索关键字、请求的页面 URL、浏览器和花费在页面上的总时间。谷歌分析是最受欢迎的免费网站服务提供商之一。通过分析所有这些信息，我们可以了解访问者在网站上的行为。通过描述性分析，我们可以根据访问者对网页或其他网络属性的上瘾程度来识别它们的重要性。对于一个电子商务网站，我们可以根据访问总数、页面浏览量和访问者在页面上花费的时间来识别受欢迎的产品。此外，预测分析可以在网络数据上实现，以预测业务。
  • 搜索引擎:假设我们有一大堆文档，想要在文档中搜索一个特定的关键词，使用 Hadoop MapReduce 的倒排索引将帮助我们找到关键词，这样我们就可以构建一个大数据的搜索引擎。
  • 股市分析:假设我们已经收集了很长一段时间的股市数据(大数据)，现在想要识别模式，并对下一个时间段进行预测。这需要训练所有历史数据集。然后，我们可以使用几个带有 Hadoop MapReduce 的机器学习库来计算上述时间段的股市变化频率。

此外，有太多可能的 MapReduce 应用可以用来提高业务成本。

学习用 R 写 Hadoop MapReduce 的不同方法

我们知道，使用 MapReduce 进行 Hadoop 大数据处理对统计人员、网络分析师和产品经理来说是一件大事，他们过去使用 R 工具进行分析，因为使用 Hadoop 将分析迁移到 MapReduce 需要 MapReduce 的补充编程知识。此外，我们知道 R 是一个不断普及的工具；有很多正在开发的用于与 R 集成的包/库，所以为了开发一个能够以 R 的日志和 Hadoop 的计算能力运行的 MapReduce 算法或程序，我们需要 R 和 Hadoop 的中间件。rhadop、RHIPE 和 Hadoop streaming 是帮助在 r 内开发和执行 Hadoop MapReduce 的中间件，在这最后一节，我们将讨论 rhadop、RHIPE 和介绍 Hadoop streaming，从后面的章节开始，我们将纯粹用这些包开发 MapReduce。

学习 RHadoop

RHadoop 是一个伟大的 R 开源软件框架，用于通过 R 函数在 Hadoop 平台上执行数据分析。RHadoop 由 Revolution Analytics 开发，该公司是基于统计计算开源 R 项目的领先商业软件和服务提供商。RHadoop 项目有三个不同的 R 包:rhdfs、rmr和rhbase。所有这些包都在 Cloudera Hadoop 发行版 CDH3、CDH4 和 R 2.15.0 上实现和测试。此外，这些都是用革命分析的 4.3、5.0 和 6.0 版本测试的。

这三个不同的 R 包是基于 Hadoop 的两个主要功能 HDFS 和 MapReduce 设计的:

  • rhdfs:这是一个 R 包，提供所有 Hadoop HDFS 对 R 的访问，所有分布式文件都可以用 R 函数管理。
  • rmr:这是一个 R 包，为 R 提供 Hadoop MapReduce 接口，借助这个包，可以轻松开发 Mapper 和 Reduce。
  • rhbase:这个是一个 R 包，通过 R 在 HBase 分布式数据库处理数据。

学习 RHIPE

R 和 Hadoop 集成编程环境 ( RHIPE )是一个免费的开源项目。RHIPE 广泛用于执行带有 D & R 分析的大数据分析。D & R 分析用于分割巨大的数据，在分布式网络上并行处理产生中间输出，最后将所有这些中间输出重组为一个集合。RHIPE 旨在 Hadoop 平台上对 R 中的复杂大数据进行 D & R 分析。RHIPE 是由 Saptarshi Joy Guha(Mozilla Corporation 的数据分析师)和她的团队开发的，作为她在普渡统计部门博士论文的一部分。

学习 Hadoop 流

Hadoop 流是 Hadoop 发行版附带的实用程序。该实用程序允许您使用任何可执行文件或脚本作为映射器和/或缩减器来创建和运行映射缩减作业。R、Python、Ruby、Bash、Perl 等都支持这一点。我们将使用带有 bash 脚本的 R 语言。

此外，还有一个名为HadoopStreaming的 R 包，它是为了在 R 脚本的帮助下对 Hadoop 集群进行数据分析而开发的，这是一个使用 R 进行 Hadoop 流的接口。此外，它还允许在没有 Hadoop 的情况下运行 MapReduce 任务。这个包是由传感网络公司的首席科学家大卫·罗森伯格(T2)开发的。他在机器学习和统计建模方面有专长。

总结

在这一章中，我们已经看到了什么是 Hadoop MapReduce，以及如何开发和运行它。在下一章中，我们将学习如何安装 RHIPE 和 RHadoop，并通过示例开发 MapReduce 及其可用的函数库。

三、集成 R 和 Hadoop

在前两章中，我们获得了关于如何安装 R 和 Hadoop 工具的基本信息。此外，我们还了解了 Hadoop 的主要功能，以及为什么它们与大数据解决方案集成在一起，以解决业务数据问题。因此，借助 R 和 Hadoop 的集成，我们可以将数据分析转向大数据分析。这两种中间件在一起使用时仍在不断改进。

在第二章编写 Hadoop MapReduce 程序中，我们学习了如何在 Hadoop 中编写 MapReduce 程序。在这一章中，我们将学习在 Hadoop 集群上运行的 MapReduce 程序。本章将提供关于 RHIPE 和 RHadoop 的开发教程。在安装了 R 和 Hadoop 之后，我们将看到如何使用简单的步骤来集成 R 和 Hadoop。

在我们开始安装之前，让我们看看在一个组织中集成 R 和 Hadoop 有什么好处。由于统计学家和数据分析师经常使用 R 工具进行数据探索和数据分析，Hadoop 集成对于处理大规模数据是一大福音。类似地，使用 Hadoop 工具(如系统)来组织数据仓库的数据工程师可以执行这样的逻辑分析操作，以获得信息丰富的见解，这些见解可以通过与 R 工具集成来操作。

因此，这种数据驱动的工具和技术的集成可以构建一个强大的可扩展系统，该系统具有这两者的特点。

Integrating R and Hadoop

链接 R 和 Hadoop 的三种方式如下:

  • 瑞佩
  • RHadoop
  • Hadoop 流

在本章中，我们将学习与 RHIPE 和 RHadoop 的集成和分析。Hadoop 流将在第 4 章、中介绍使用带有 R 的 Hadoop 流。

引入 RHIPE

RHIPE 代表 R 和 Hadoop 集成编程环境。正如在http://www.datadr.org/上提到的，在希腊语中是“一瞬间”的意思，是 R 和 Hadoop 的合并。它最早是由萨普塔什古哈为他 2012 年在普渡大学统计系的博士论文开发的。目前，这是由普渡大学统计系团队和其他活跃的谷歌讨论组进行的。

RHIPE 包使用 分割和重组技术对大数据进行数据分析。在这种技术中，数据被分成子集，通过特定的 R 分析操作对这些子集执行计算，并组合输出。RHIPE 主要设计用于实现两个目标，如下所示:

  • 允许您对大数据和小数据进行深入分析。
  • 允许用户使用低级语言在 R 中执行分析操作。RHIPE 设计有几个功能，可以使用简单的 R 控制台帮助执行 Hadoop 分布式文件系统 ( HDFS )以及 MapReduce 操作。

与 HDFS 和 MapReduce 操作相比，RHIPE 是一个低级接口。使用 RHIPE 的最新支持版本 0.73.1 作为Rhipe_0.73.1-2.tar.gz。

安装 RHIPE

由于 RHIPE 是 R 和 Hadoop 的连接器，我们需要 Hadoop 和 R 按照以下顺序安装在我们的机器上或集群中:

  1. 安装 Hadoop。
  2. 安装 r。
  3. 安装协议缓冲区。
  4. 设置环境变量。
  5. 正在安装 rJava。
  6. 安装 RHIPE。

让我们从安装开始。

安装 Hadoop

当我们在这里将 R 和 Hadoop 与 RHIPE 包库集成时，我们需要在我们的机器上安装 Hadoop 。根据要分析的数据大小，可以任意选择是单节点安装还是多节点安装。

因为我们已经学习了如何在 Ubuntu 中安装 Hadoop，所以我们不打算在这里重复这个过程。如果您还没有安装，请参考第 1 章、准备使用 R 和 Hadoop ，获取指导。

安装 R

如果我们使用多节点 Hadoop 架构，则有多个任务跟踪器节点用于执行 MapReduce 作业。因此，我们需要在所有这些任务跟踪器节点上安装 R。这些任务跟踪器节点将通过开发的地图开始处理数据子集，并通过考虑关键值减少逻辑。

安装协议缓冲区

协议缓冲区只是序列化数据，使其独立于平台、中立且健壮(主要用于结构化数据)。谷歌使用相同的协议进行数据交换。RHIPE 依赖协议缓冲区 2.4.1 在网络上进行数据序列化。

可以使用以下命令进行安装:

## For downloading the protocol buffer 2.4.1
wget http://protobuf.googlecode.com/files/protobuf-2.4.1.tar.gz

## To extracting the protocol buffer
tar -xzf protobuf-2.4.1.tar.gz

## To get in to the extracted protocol buffer directory
cd protobuf-2.4.1

## For making install the protocol buffer
./configure # --prefix=...
make
make install

环境变量

为了使 RHIPE 能够正确编译和工作，最好确保适当设置以下环境变量:

对于配置 Hadoop 库，我们需要在hduser (Hadoop 用户)的~./bashrc文件中设置两个变量PKG_CONFIG_PATH和LD_LIBRARY_PATH，以便在用户登录系统时自动设置。

这里，PKG_CONFIG_PATH是保存pkg-config脚本路径的环境变量，用于检索系统中已安装库的信息，LD_LIBRARY_PATH是保存本机共享库路径的环境变量。

export PKG_CONFIG_PATH = /usr/local/lib
export LD_LIBRARY_PATH = /usr/local/lib

您也可以从您的控制台设置所有这些变量，如下所示:

Sys.setenv(HADOOP_HOME="/usr/local/hadoop/")
Sys.setenv(HADOOP_BIN="/usr/local/hadoop/bin")
Sys.setenv(HADOOP_CONF_DIR="/usr/local/hadoop/conf")

其中HADOOP_HOME用于指定 Hadoop 目录的位置，HADOOP_BIN用于指定 Hadoop 二进制文件的位置，HADOOP_CONF_DIR用于指定 Hadoop 的配置文件。

设置变量是临时的，并且在特定的 R 会话之前是有效的。如果我们想使这个变量永久化，就像在 R 会话初始化时自动初始化一样，我们需要将这些变量设置到/etc/R/Renviron文件中，就像我们在特定用户配置文件的.bashrc中设置环境变量一样。

rJava 包安装

由于 RHIPE 是一个 Java 包，它就像是 R 和 Hadoop 之间的 Java 桥梁。RHIPE 将输入数据序列化为 Java 类型，该类型必须通过集群进行序列化。它需要一个 Java 的低级接口，由 rJava 提供。因此，我们将安装 rJava 来实现 RHIPE 的功能。

## For installing the rJava Package will be used for calling java libraries from R.
install.packages("rJava")

安装 RHIPE

现在，是时候从 RHIPE 包的存储库中安装它了。

## Downloading RHIPE package from RHIPE repository
Wget http://ml.stat.purdue.edu/rhipebin/Rhipe_0.73.1-2.tar.gz

## Installing the RHIPE package in R via CMD command
R CMD INSTALL Rhipe_0.73.1.tar.gz

现在，我们已经准备好了一个 RHIPE 系统，可以用 R 和 Hadoop 进行数据分析。

了解 RHIPE 的架构

让我们了解 RHIPE 库包的工作原理，该库包旨在集成 R 和 Hadoop 以实现有效的大数据分析。

Understanding the architecture of RHIPE

RHIPE 的成分

有许多 Hadoop 组件将用于 R 和 Hadoop 的数据分析操作。

RHIPE 的成分如下:

  • rcclient:rcclient 是一个 R 应用，调用 JobTracker 执行作业，并带有若干 MapReduce 作业资源的指示，如 Mapper、Reducer、输入格式、输出格式、输入文件、输出文件以及其他几个可以用 rcclient 处理 MapReduce 作业的参数。
  • 作业跟踪器:一个作业跟踪器是 Hadoop MapReduce 操作的主节点，用于初始化和监控 Hadoop 集群上的 MapReduce 作业。
  • 任务跟踪器:任务跟踪器是 Hadoop 集群中的从节点。它按照作业跟踪器给出的命令执行地图缩减作业，检索输入数据块，并在其上运行特定于 R 的Mapper和Reducer。最后，输出将被写入 HDFS 目录。
  • HDFS : HDFS 是一个分布在 Hadoop 集群上的文件系统，有几个数据节点。它为各种数据操作提供数据服务。

了解 RHIPE 样品

在本节中，我们将创建两个 RHIPE MapReduce 示例。这两个例子是用 RHIPE 包中 Hadoop MapReduce 作业的基本实用程序定义的。

RHIPE 示例程序(仅限地图)

MapReduce 问题定义:这个 MapReduce 示例程序的目标是在 Hadoop 环境下，通过对数值数据使用min和max函数来测试 RHIPE 安装。由于这是一个示例程序，我们只包括了地图阶段，它将把输出存储在 HDFS 目录中。

要用 RHIPE 开始开发，我们需要通过加载库并调用 rhinit()方法来初始化 RHIPE 子系统。

## Loading the RHIPE library
library(Rhipe)

## initializing the RHIPE subsystem, which is used for everything. RHIPE will not work if rhinit is not called.
rhinit()

输入:我们插入一个数值，而不是使用文件作为输入。

映射阶段:这个 MapReduce 程序的映射阶段将调用 10 个不同的迭代，在所有这些迭代中，将根据它们的迭代号生成从 1 到 10 的随机数。之后，将计算生成的数字的最大值和最小值。

## Defining the Map phase

Map(function(k,v){

## for generating the random deviates
 X  runif(v)

## for emitting the key-value pairs with key – k and
## value – min and max of generated random deviates.
 rhcollect(k, c(Min=min(x),Max=max(x))
}

输出:最后，地图阶段的输出在这里将被视为该地图缩减作业的输出，并将在/app/hadoop/RHIPE/存储到 HDFS。

通过 RHIPE 包的 rhwatch()方法定义 MapReduce 作业:

## Create and running a MapReduce job by following
job = rhwatch(map=map,input=10,reduce=0,
output="/app/Hadoop/RHIPE/test",jobname='test')

读取来自 HDFS 的 MapReduce 输出:

## Read the results of job from HDFS
result <- rhread(job)

要以更易读的表格格式显示结果，请使用以下代码:

## Displaying the result
outputdata  <- do.call('rbind', lapply(result, "[[", 2))

输出:

RHIPE sample program (Map only)

字数

MapReduce 问题定义:这个 RHIPE MapReduce 程序被定义用于识别在提供的输入文本文件中出现的所有单词的频率。

还要注意，这和我们在第 2 章、编写 Hadoop MapReduce 程序中看到的问题是一样的。

## Loading the RHIPE Library
library(Rhipe)

输入:我们将使用 Hadoop 发行版附带的CHANGES.txt文件，并将其与此 MapReduce 算法一起使用。通过使用以下命令，我们将它复制到 HDFS:

rhput("/usr/local/hadoop/CHANGES.txt","/RHIPE/input/")

映射阶段:映射阶段包含从文件中读取所有单词并将它们全部赋值给1的代码。

## Defining the Map functionw_map<-expression({ words_vector<-unlist(strsplit(unlist(map.values)," ")) lapply(words_vector,function(i) rhcollect(i,1))
})

还原阶段:通过这个还原任务，我们可以计算出输入文本文件中单词的总出现频率。

## For reference, RHIPE provides a canned version
Reduce = rhoptions()$templates$scalarsummer

## Defining the Reduce functionw_reduce<-expression(pre={total=0},reduce={total<-sum(total,unlist(reduce.values))},post={rhcollect(reduce.key,total)})

定义 MapReduce 作业对象:定义了字数映射器和缩减器之后，我们需要设计driver方法，通过依次调用Mapper和Reducer来执行这个 MapReduce 作业。

## defining and executing a MapReduce job object
Job1 <- rhwatch(map=w_map,reduce=w_reduce, ,input="/RHIPE/input/",output="/RHIPE/output/", jobname="word_count")

读取 MapReduce 输出:

## for reading the job output data from HDFS
Output_data <- rhread(Job1)results <- data.frame(words=unlist(lapply(Output_data,"[[",1)), count =unlist(lapply(Output_data,"[[",2)))

MapReduce 作业的输出将存储到output_data，我们将把这个输出转换成 R 支持的数据帧格式。数据帧输出将存储到results变量中。为了在数据框中显示 MapReduce 输出，格式如下:

head (results)输出:

Word count

tail (results)输出:

Word count

了解 RHIPE 功能参考

RHIPE 是专门为在 Hadoop 上提供低级接口而设计的。因此，拥有 RHIPE 包的 R 用户可以轻松地对存储在 HDFS 的大型数据集执行 Hadoop 数据操作，就像 R 中调用的 print()函数一样

现在我们将看到 RHIPE 库中所有可用方法的所有可能的功能用途。所有这些方法分为三类:初始化、 HDFS 和 MapReduce 操作。

初始化

我们使用以下命令进行初始化:

  • rhinit: This is used to initialize the Rhipe subsystem.

    rhinit(TRUE,TRUE)

HDFS

我们使用以下命令进行 HDFS 操作:

  • rhls: This is used to retrieve all directories from HDFS.

    它的语法是rhls(path)

    rhls("/")

    输出:

    HDFS

  • hdfs.getwd:此用于获取当前工作 HDFS 目录。它的语法是hdfs.getwd()

  • hdfs.setwd:此用于设置当前工作 HDFS 目录。它的语法是hdfs.setwd("/RHIPE")

  • rhput:这是用来将文件从本地目录复制到 HDFS。它的语法是rhput(src,dest)和rhput("/usr/local/hadoop/NOTICE.txt","/RHIPE/")。

  • rhcp:这是用来将文件从一个 HDFS 位置复制到另一个 HDFS 位置。它的语法是rhcp('/RHIPE/1/change.txt','/RHIPE/2/change.txt')。

  • rhdel:这里是用来从 HDFS 删除一个目录/文件。它的语法是rhdel("/RHIPE/1")。

  • rhget:此用于将 HDFS 文件复制到本地目录。它的语法是rhget("/RHIPE/1/part-r-00000", "/usr/local/")。

  • rwrite:这个是用来给 HDFS 写 R 数据的。其语法为rhwrite(list(1,2,3),"/tmp/x")。

MapReduce

我们使用以下命令进行 MapReduce 操作:

  • rhwatch:此用于准备、提交、监控 MapReduce 作业。

    # Syntax:
rhwatch(map, reduce, combiner, input, output, mapred,partitioner,mapred, jobname)

## to prepare and submit MapReduce job:

z=rhwatch(map=map,reduce=0,input=5000,output="/tmp/sort",mapred=mapred,read=FALSE)

results <- rhread(z)

  • rhex:这是用来在 Hadoop 集群上执行 MapReduce 作业。

    ## Submit the job
rhex(job)

  • rhjoin:这里是用来检查 MapReduce 作业是否完成。它的语法是rhjoin(job)。

  • rhkill:这个用来杀死正在运行的 MapReduce 作业。其语法为rhkill(job)。

  • rhoptions:此用于获取或设置 RHIPE 配置选项。它的语法是rhoptions()。

  • rhstatus:此用于获取 RHIPE MapReduce 作业的状态。它的语法是rhstatus(job)。

    rhstatus(job, mon.sec = 5, autokill = TRUE,showErrors = TRUE, verbose = FALSE, handler = NULL)

介绍 RHadoop

RHadoop 是三个 R 包的集合，用于在 R 环境中提供大型数据操作。它是由 Revolution Analytics 开发的，Revolution Analytics 是基于 R. RHadoop 的领先商业软件提供商，提供三个主要的 R 包:rhdfs、rmr和rhbase。它们都提供了不同的 Hadoop 特性。

  • rhdfs是一个 R 接口，用于从 R 控制台提供 HDFS 可用性。当 Hadoop MapReduce 程序在 HDFS 上编写输出时，通过调用rhdfs方法很容易访问它们。R 程序员可以轻松地对分布式数据文件执行读写操作。基本上，rhdfs包调用后端的 HDFS API 来操作存储在 HDFS 的数据源。
  • rmr是一个 R 接口，用于在 R 环境中提供 Hadoop MapReduce 工具。所以，R 程序员只需要将他们的应用逻辑划分到图中，减少阶段，用rmr方法提交。之后，rmr调用 Hadoop 流 MapReduce API，将多个作业参数作为输入目录、输出目录、映射器、缩减器等，在 Hadoop 集群上执行 R MapReduce 作业。
  • rhbase是一个 R 接口，用于通过一个节俭服务器操作存储在分布式网络中的 Hadoop HBase 数据源。rhbase包设计有多种初始化、读/写和表操作方法。

这里不需要安装所有三个 RHadoop 包来运行带有 R 和 Hadoop 的 Hadoop MapReduce 操作。如果我们已经将我们的输入数据源存储在了 HBase 数据源，我们需要安装rhbase；否则我们需要rhdfs和rmr套餐。由于 Hadoop 最受欢迎的两个主要功能是 Hadoop MapReduce 和 HDFS，这两个功能都将在 RHadoop rhdfs和rmr包的帮助下在 R 控制台中使用。这些包足够从 r 运行 Hadoop MapReduce，基本上rhdfs提供 HDFS 数据操作，rmr提供 MapReduce 执行操作。

RHadoop 还包括另一个名为quick check的包，它是设计用于调试由rmr包定义的已开发的 MapReduce 作业。

在下一节中，我们将看到它们的架构关系以及安装步骤。

了解 RHadoop 的架构

由于 Hadoop 因 HDFS 和 MapReduce 而高度流行，Revolution Analytics 开发了独立的 R 包，即rhdfs、rmr和rhbase。RHadoop 的架构如下图所示:

Understanding the architecture of RHadoop

RHadoop 生态系统

安装 RHadoop

在本节中，我们将学习三个 RHadoop 包的一些安装技巧，包括它们的先决条件。

  • R and Hadoop installation: As we are going to use an R and Hadoop integrated environment, we need Hadoop as well as R installed on our machine. If you haven't installed yet, see Chapter 1, Getting Ready to Use R and Hadoop. As we know, if we have too much data, we need to scale our cluster by increasing the number of nodes. Based on this, to get RHadoop installed on our system we need Hadoop with either a single node or multimode installation as per the size of our data.

    RHadoop 已经用 Cloudera、Hortonworks 和 MapR 提供的几个 Hadoop 发行版进行了测试。

  • Installing the R packages: We need several R packages to be installed that help it to connect R with Hadoop. The list of the packages is as follows:

    • 棕色
    • RJSONIO
    • 迭代工具
    • 摘要
    • Rcpp 公司
    • http(http)
    • 功能的
    • dev 工具
    • -你好
    • 重塑 2

    我们可以通过在 R 控制台中调用以下 R 命令的执行来安装它们:

    install.packages( c('rJava','RJSONIO', 'itertools', 'digest','Rcpp','httr','functional','devtools', 'plyr','reshape2'))

  • Setting environment variables: We can set this via the R console using the following code:

    ## Setting HADOOP_CMD
Sys.setenv(HADOOP_CMD="/usr/local/hadoop/bin/hadoop")

## Setting up HADOOP_STREAMING
Sys.setenv(HADOOP_STREAMING="/usr/local/hadoop/contrib/streaming/hadoop-streaming-1.0.3.jar")

    或者，我们也可以通过命令行设置 R 控制台，如下所示:

    export HADOOP_CMD=/usr/local/Hadoop
export HADOOP_STREAMING=/usr/lib/hadoop-0.20-mapreduce/contrib/streaming/hadoop-streaming-2.0.0-mr1-cdh4.1.1.jar

  • 安装 RHadoop [ rhdfs、rmr、rhbase ]

    1. 从革命分析的 GitHub 存储库中下载 RHadoop 包:https://github.com/RevolutionAnalytics/RHadoop。

      • rmr : [ rmr-2.2.2.tar.gz ]
      • rhdfs : [ rhdfs-1.6.0.tar.gz ]
      • rhbase : [ rhbase-1.2.0.tar.gz ]

    2. Installing packages.

      • 对于 rmr，我们使用:

        R CMD INSTALL rmr-2.2.2.tar.gz

      • 对于rhdfs我们使用:

        R CMD INSTALL rmr-2.2.2.tar.gz

      • 对于rhbase我们使用:

        R CMD INSTALL rhbase-1.2.0.tar.gz

      类型

      要安装 rhbase，我们需要在我们的 Hadoop 集群上安装 hbase 和 Zookeeper。

理解 RHadoop 示例

一旦我们完成了 rhadop 的安装，我们可以通过使用 rhadop 示例程序中的rmr2和rhdfs库运行 MapReduce 作业来测试设置，如下所示:

## loading the libraries
library(rhdfs')
library('rmr2')

## initializing the RHadoop
hdfs.init()

# defining the input data
small.ints = to.dfs(1:10)

## Defining the MapReduce job
mapreduce(
# defining input parameters as small.ints hdfs object, map parameter as function to calculate the min and max for generated random deviates.
  input = small.ints, 
  map = function(k, v)
  {
lapply(seq_along(v), function(r){

  x <- runif(v[[r]])
    keyval(r,c(max(x),min(x))) 
  })})

运行这几行后，只需按 Ctrl + 回车即可执行本 MapReduce 程序。如果成功，最后一行将出现，如下图所示:

Understanding RHadoop examples

其中最后一行的字符表示 MapReduce 作业的输出位置。

要读取执行的 MapReduce 作业的结果，请复制最后一行中提供的输出位置，并将其传递给rhdfs的from.dfs()功能。

Understanding RHadoop examples

其中前一个输出的第一列表示最大值，第二列表示最小值。

字数

MapReduce 问题定义:这个 RHadoop MapReduce 程序被定义为识别在提供的输入文本文件中出现的所有单词的频率。

此外，请注意，这与我们在第 2 章编写 Hadoop MapReduce 程序中关于 RHIPE 的上一节中学习的 MapReduce 问题相同。

wordcount = function(input, output = NULL, pattern = " "){

地图阶段:此map功能将逐行读取文本文件，并用空格分割。该映射阶段将为映射器捕获的所有字分配1作为值。

wc.map = function(., lines) {
 keyval(
 unlist(
 strsplit(
 x = lines,
 split = pattern)),
 1)}

减少相位:减少相位将通过对具有相同键的单词执行求和操作来计算所有单词的总频率。

wc.reduce = function(word, counts ) {
 keyval(word, sum(counts))}

定义 MapReduce 作业:在定义了字数映射器和 Reduce 之后，我们需要创建driver方法，开始执行 MapReduce。

# To execute the defined Mapper and Reducer functions
# by specifying the input, output, map, reduce and input.format as parameters.

# Syntax:
# mapreduce(input, output, input.format, map,reduce,
# combine)

mapreduce(input = input ,
 output = output,
 input.format = "text",
 map = wc.map,
 reduce = wc.reduce,
 combine = T)}

执行 MapReduce 作业:我们将通过将输入数据位置作为参数传递给wordcount函数来执行 RHadoop MapReduce 作业。

wordcount('/RHadoop/1/')

探索wordcount输出:

from.dfs("/tmp/RtmpRMIXzb/file2bda5e10e25f")

理解 RHadoop 函数引用

RHadoop 有三个不同的包，分别是 HDFS、MapReduce 和 HBase 操作，用于对数据执行操作。

下面我们来看看如何使用rmr和rhdfs包功能:

HDFS 包

分类功能有:

  • Initialization

    • hdfs.init:此用于初始化rhdfs包。它的语法是hdfs.init()。
    • hdfs.defaults:用于检索和设置rhdfs默认值。它的语法是hdfs.defaults()。

    要检索hdfs配置默认值，请参考以下屏幕截图:

    The hdfs package

  • 文件操作

    • hdfs.put:这个用于将文件从本地文件系统复制到 HDFS 文件系统。

      hdfs.put('/usr/local/hadoop/README.txt','/RHadoop/1/')

    • hdfs.copy:这个用来将文件从 HDFS 目录复制到本地文件系统。

      hdfs.put('/RHadoop/1/','/RHadoop/2/')

    • hdfs.move:这个用来把一个文件从一个 HDFS 目录移动到另一个 HDFS 目录。

      hdfs.move('/RHadoop/1/README.txt','/RHadoop/2/')

    • hdfs.rename:此用于将存放在 HDFS 的文件从

      hdfs.rename('/RHadoop/README.txt','/RHadoop/README1.txt')

      重命名

    • hdfs.delete:此用于从

      hdfs.delete("/RHadoop")

      中删除 HDFS 文件或目录

    • hdfs.rm:此用于从

      hdfs.rm("/RHadoop")

      中删除 HDFS 文件或目录

    • hdfs.chmod:这个是用来更改一些文件的权限的。

      hdfs.chmod('/RHadoop', permissions= '777')

  • 文件读/写:

    • hdfs.file:此用于将文件初始化为用于读/写操作。

      f = hdfs.file("/RHadoop/2/README.txt","r",buffersize=104857600)

    • hdfs.write:这个是用来通过流媒体写入 HDFS 存储的文件的。

      f = hdfs.file("/RHadoop/2/README.txt","r",buffersize=104857600)
hdfs.write(object,con,hsync=FALSE)

    • hdfs.close:这是用来在文件操作完成时关闭流。它将关闭流，并且不允许进一步的文件操作。

      hdfs.close(f)

    • hdfs.read: This is used to read from binary files on the HDFS directory. This will use the stream for the deserialization of the data.

      f = HDFS . file("/Rhadoop/2/README . txt "，" r "，buffersize=104857600)

      m = hdfs.read(f)

      c =罗托卡(m)

      印刷(c)

  • 目录操作:

    • hdfs.dircreate或hdfs.mkdir :这两个功能都将用于在 HDFS 文件系统上创建目录。

      hdfs.mkdir("/RHadoop/2/")

    • hdfs.rm 或hdfs.rmr或hdfs.delete -从 HDFS 删除目录或文件。

      hdfs.rm("/RHadoop/2/")

  • Utility:

    • hdfs.ls: This is used to list the directory from HDFS.

      Hdfs.ls('/')

      The hdfs package

    • hdfs.file.info:用于获取存储在 HDFS 的文件的元信息。

      hdfs.file.info("/RHadoop")

    The hdfs package

rmr 包

功能类别如下:

  • 用于存储和检索数据:

    • to.dfs: This is used to write R objects from or to the filesystem.

      small.ints = to.dfs(1:10)

    • from.dfs: This is used to read the R objects from the HDFS filesystem that are in the binary encrypted format.

      from . DFS('/tmp/rtmprmizb/file 2 bda3fa 07850 ')

  • 对于 MapReduce :

    • mapreduce: This is used for defining and executing the MapReduce job.

      mapreduce(输入、输出、映射、缩减、组合、input.fromat、output.format、verbose)

    • keyval: This is used to create and extract key-value pairs.

      keyval（key， val）

总结

由于 RHadoop 被认为是成熟的，我们将在后面的章节中进行数据分析时考虑它。在第 5 章、用 R 和 Hadoop 学习数据分析和第 6 章、用机器学习理解大数据分析中，我们将深入探讨一些大数据分析技术，并看看 RHadoop 如何解决现实世界的问题。到目前为止，我们已经学习了如何使用 RHIPE 和 RHadoop 用 R 和 Hadoop 编写 MapReduce 程序。在下一章中，我们将看到如何使用 Hadoop 流实用程序以及 Hadoop 流 R 包编写 Hadoop MapReduce 程序。

四、使用 Hadoop 流

在前一章中，我们学习了如何在 RHIPE 和 RHadoop 的帮助下集成 R 和 Hadoop，以及示例。在本章中，我们将讨论以下主题:

  • 了解 Hadoop 流的基础知识
  • 了解如何使用 R 运行 Hadoop 流
  • 探索 HadoopStreaming R 包

了解 Hadoop 流的基础知识

Hadoop 流是一个 Hadoop 实用程序，用于运行 Hadoop MapReduce 作业以及可执行脚本，如映射器和减速器。这类似于 Linux 中的管道操作。这样，文本输入文件被打印在流(stdin)上，作为映射器的输入，映射器的输出(stdout)作为减速器的输入；最后，Reducer 将输出写入 HDFS 目录。

Hadoop 流实用程序的主要优点是，它允许在 Hadoop 集群上执行 Java 和非 Java 编程的 MapReduce 作业。此外，它还负责运行 MapReduce 作业的进度。Hadoop 流支持 Perl、Python、PHP、R 和 C++编程语言。要运行用其他编程语言编写的应用，开发人员只需将应用逻辑翻译成带有键和值输出元素的 Mapper 和 Reducer 部分。我们在第 2 章、编写 Hadoop MapReduce 程序中了解到，要创建 Hadoop MapReduce 作业，我们需要映射器、减速器和驱动程序作为三个主要组件。在这里，当我们用 R 和 Hadoop 实现 MapReduce 时，创建用于运行 MapReduce 作业的驱动程序文件是可选的。

这一章是为了集成 R 和 Hadoop 而写的。所以我们将看到带有 Hadoop 流的 R 的例子。现在，我们将看到如何使用 Hadoop 流和用 Mapper 和 Reducer 编写的 R 脚本。从下图中，我们可以识别 Hadoop 流 MapReduce 作业的各个组件。

Understanding the basics of Hadoop streaming

Hadoop 流组件

现在，假设我们已经将映射器和缩减器实现为code_mapper.R和code_reducer.R。我们将看看如何在 R 和 Hadoop 的集成环境中运行它们。这可以通过带有各种通用和流选项的 Hadoop 流命令来运行。

让我们看看 Hadoop 流命令的格式:

 bin/hadoop command [generic Options] [streaming Options]

下图显示了 Hadoop 流的执行示例，这是一个具有多个流选项的 MapReduce 作业。

Understanding the basics of Hadoop streaming

Hadoop 流命令选项

在上图中，整个 Hadoop 流 MapReduce 作业需要大约六个独特的重要组件。除了 jar，所有都是流选项。

以下是前面的 Hadoop 流命令的逐行描述:

  • 第 1 行:用于指定 Hadoop jar 文件(设置 Hadoop jar 的类路径)
  • 第 2 行:用于指定 HDFS 的输入目录
  • 第 3 行:用于指定 HDFS 的输出目录
  • 第 4 行:用于使文件对本地机器可用
  • 第 5 行:用于将可用的 R 文件定义为映射器
  • 第 6 行:用于使文件对本地机器可用
  • 第 7 行:用于将可用的 R 文件定义为减速器

前面命令的六个主要 Hadoop 流组件如下所示:

  • jar: 这个选项用于运行一个带有编码类的 jar，这些编码类是为 Java 以及其他编程的 Mappers 和 Reducers 提供流功能而设计的。它被称为 Hadoop 流罐。
  • 输入 : 该选项用于指定 Hadoop 流 MapReduce 作业的输入数据集(存储在 HDFS)的位置。
  • 输出:这个选项用来告诉 HDFS 输出目录(MapReduce 作业的输出将被写入的地方)到 Hadoop 流式 MapReduce 作业。
  • 文件:该选项用于将映射器、缩减器和组合器等 MapReduce 资源复制到计算机节点(任务跟踪器)，使其成为本地的。
  • 映射器:该选项用于识别可执行文件Mapper。
  • 减速器:该选项用于识别可执行的Reducer文件。

还有其他 Hadoop 流命令选项，但它们是可选的。让我们来看看它们:

  • inputformat:通过指定 Java 类名来定义输入数据格式。默认为TextInputFormat。
  • outputformat:通过指定 Java 类名来定义输出数据格式。默认为TextOutputFormat。
  • partitioner:此用于包含用代码编写的类或文件，用于将输出划分为映射器阶段的(键、值)对。
  • combiner:这个是用来包含用聚合键值来减少 Mapper 输出的代码编写的类或者文件。此外，我们可以使用默认组合器，在将映射器的输出提供给缩减器之前，它将简单地组合所有关键属性值。
  • cmdenv:该选项将环境变量传递给流命令。比如我们可以通过R_LIBS = /your /path /to /R /libraries。
  • inputreader:这个可以代替inputformat类来指定记录阅读器类。
  • verbose:这个是用来啰嗦输出的。
  • numReduceTasks:此用于指定减速器的数量。
  • mapdebug:这个用来在 Mapper 任务失败时调试Mapper文件的脚本。
  • reducedebug:此用于在减速器任务失败时调试Reducer文件的脚本。

现在，是时候看看 Hadoop 流 MapReduce 作业的一些通用选项了。

  • conf:用于指定应用配置文件。

    -conf configuration_file

  • D:用于定义特定 MapReduce 或 HDFS 属性的值。例如:

  • -D property = value or to specify the temporary HDFS directory.

    -D dfs.temp.dir=/app/tmp/Hadoop/

    或者指定零减速器的总数:

    -D mapred.reduce.tasks=0

    注

    -D选项仅在工具实现时有效。

  • fs:用于定义 Hadoop 名称节点。

    -fs localhost:port

  • jt:用于定义 Hadoop 作业跟踪器。

    -jt localhost:port

  • files:用于指定来自 HDFS 的大型或多个文本文件。

    -files hdfs://host:port/directory/txtfile.txt

  • libjars:这是用来指定要包含在类路径中的多个 jar 文件。

    -libjars  /opt/ current/lib/a.jar, /opt/ current/lib/b.jar

  • archives:用于指定要在本地机器上取消归档的 jar 文件。

    -archives hdfs://host:fs_port/user/testfile.jar

了解如何用 R 运行 Hadoop 流

现在，我们理解了什么是 Hadoop 流，以及如何使用 Hadoop 通用和流选项调用它。接下来，是时候知道如何用 R 开发和运行 R 脚本了。为此，我们可以考虑一个比简单的字数统计程序更好的例子。

MapReduce 操作的四个不同阶段解释如下:

  • 理解 MapReduce 应用
  • 了解如何编写 MapReduce 应用
  • 了解如何运行 MapReduce 应用
  • 了解如何探索 MapReduce 应用的输出

了解地图缩减应用

问题定义:问题是通过地理位置分割一个页面访问。在这个问题中，我们要考虑的是http://www.gtuadmissionhelpline.com/网站，该网站是为那些正在寻找古吉拉特理工大学入学机会的学生提供指导而开发的。该网站包含各种领域的学院详细信息，如工程(文凭、学位和硕士)、医学、酒店管理、建筑、药学、工商管理硕士和 MCA。有了这个 MapReduce 应用，我们将从地理上确定访问者感兴趣的领域。

例如，来自瓦尔萨德市的大多数在线访问者更频繁地访问 MBA 院校的页面。基于此，我们可以识别 Valsad 学生的心态；他们对获得工商管理硕士领域的录取非常感兴趣。因此，有了这个网站流量数据集，我们可以确定城市的兴趣水平。现在，如果瓦尔萨德没有 MBA 学院，对他们来说将是一个大问题。他们需要搬迁到其他城市；这可能会增加他们的教育成本。

通过使用这种类型的数据，古吉拉特理工大学可以为来自不同城市的学生提供信息深刻的见解。

输入数据集来源:要执行这种类型的分析，我们需要该网站的网络流量数据。谷歌分析是一种流行的免费服务，用于跟踪网站上在线访问者的元数据。谷歌分析根据不同维度的广告指标存储网络流量数据。我们需要设计一个特定的查询来从谷歌分析中提取数据集。

输入数据集:提取的谷歌分析数据集包含以下四个数据列:

  • date:这是访问日期，格式为 YYYY/MM/DD。
  • country:这是来访者的国家。
  • city:这是游客的城市。
  • pagePath:这是网站某个页面的 URL。

输入数据集的头部如下:

$ head -5 gadata_mr.csv
20120301,India,Ahmedabad,/
20120302,India,Ahmedabad,/gtuadmissionhelpline-team
20120302,India,Mumbai,/
20120302,India,Mumbai,/merit-calculator
20120303,India,Chennai,/

下图显示了预期的输出格式:

Understanding a MapReduce application

以下是的一个样本输出:

Understanding a MapReduce application

了解如何编写 MapReduce 应用

在部分，我们将了解以下两个 MapReduce 应用单元:

  • 映射代码
  • 减速器代码

让我们从映射器代码开始。

映射器代码:这个名为ga-mapper.R的 R 脚本将处理一个 MapReduce 作业的映射阶段。

映射器的工作是处理每一行，提取一对(键、值)，并将其传递给 Reducer 进行分组/聚合。在本例中，每一行都是 Mapper 的输入，输出为City:PagePath。City是关键，PagePath是价值。现在 Reducer 可以获取给定城市的所有页面路径；因此，它可以很容易地分组。

# To identify the type of the script, here it is RScript
#! /usr/bin/env Rscript
# To disable the warning massages to be printed
options(warn=-1)
# To initiating the connection to standard input
input <- file("stdin", "r")
Each line has these four fields (date, country, city, and pagePath) in the same order. We split the line by a comma. The result is a vector which has the date, country, city, and pathPath in the indexes 1,2,3, and 4 respectively.

我们分别为城市和页面路径提取第三和第四个元素。然后，它们将作为键值对写入流，并被馈送到 Reducer 进行进一步处理。

# Running while loop until all the lines are read
while(length(currentLine <- readLines(input, n=1, warn=FALSE)) > 0) {

# Splitting the line into vectors by "," separator 
 fields <- unlist(strsplit(currentLine, ","))

# Capturing the city and pagePath from fields
 city <- as.character(fields[3])
 pagepath <- as.character(fields[4])

# Printing both to the standard output
print(paste(city, pagepath,sep="\t"),stdout())

}

# Closing the connection to that input stream
close(input)

一旦映射器阶段 As(键，值)对的输出可用于标准输出，Reducers 将从stdout读取面向行的输出，并将其转换为最终的聚合键-值对。

来看看 Mapper 输出格式是怎样的，Reducer 的输入数据格式是怎样的。

减速器代码:这个名为ga_reducer.R的 R 脚本将处理 MapReduce 作业的减速器部分。

正如我们所讨论的，Mapper 的输出将被视为 Reducer 的输入。Reducer 将读取这些城市和页面路径对，并将所有值与其各自的关键元素相结合。

# To identify the type of the script, here it is RScript
#! /usr/bin/env Rscript

# Defining the variables with their initial values
city.key <- NA
page.value <- 0.0

# To initiating the connection to standard input
input <- file("stdin", open="r")

# Running while loop until all the lines are read
while (length(currentLine <- readLines(input, n=1)) > 0) {

# Splitting the Mapper output line into vectors by 
# tab("\t") separator
 fields <- strsplit(currentLine, "\t")

# capturing key and value form the fields
# collecting the first data element from line which is city
 key <- fields[[1]][1]
# collecting the pagepath value from line 
 value <- as.character(fields[[1]][2])

映射器输出写入两个主字段，以\t为分隔符，逐行写入数据；因此，我们通过使用\t从流输入中获取两个主要属性(键和值)来分割数据。

采集到密钥和值后，减速器会将其与之前采集的值进行比较。如果之前没有设置，那就设置它；否则，使用 R 中的combine功能将其与之前的字符值组合，最后将其打印到 HDFS 输出位置。

# setting up key and values

# if block will check whether key attribute is 
# initialized or not. If not initialized then it will be # assigned from collected key attribute with value from # mapper output. This is designed to run at initial time.
 if (is.na(city.key)) {
 city.key <- key
 page.value <- value
 }
 else {

# Once key attributes are set, then will match with the previous key attribute value. If both of them matched then they will combined in to one.
 if (city.key == key) {
 page.value <- c(page.value, value)

 }
 else {

# if key attributes are set already but attribute value # is other than previous one then it will emit the store #p agepath values along with associated key attribute value of city,

 page.value <- unique(page.value)
# printing key and value to standard output
print(list(city.key, page.value),stdout())
 city.key <- key
 page.value <- value
 }
 }
}

print(list(city.key, page.value), stdout())

# closing the connection
close(input)

了解如何运行 MapReduce 应用

在用 R 语言开发了 Mapper 和 Reducer 脚本之后，是时候在 Hadoop 环境中运行它们了。在我们执行这个脚本之前，建议用简单的管道操作在样本数据集上测试它们。

$ cat gadata_sample.csv | ga_mapper.R |sort | ga_reducer.R

前面的命令将在本地计算机上运行开发的映射器和缩减器脚本。但是它将类似于 Hadoop 流作业运行。我们需要针对运行时可能出现的任何问题或识别编程或逻辑错误来测试这一点。

现在，我们已经测试了映射器和减速器，并准备好使用 Hadoop 流命令运行。这个 Hadoop 流操作可以通过调用通用的jar命令和流命令选项来执行，正如我们在本章的了解 Hadoop 流的基础知识一节中所学习的。我们可以通过以下方式执行 Hadoop 流作业:

  • 从命令提示符
  • r 或 RStudio 控制台

对于这两种方式，带有通用和流命令选项的执行命令是相同的。

从命令提示符执行 Hadoop 流作业

正如我们已经在部分了解了 Hadoop 流的基础知识，使用 R 开发的 Hadoop 流 MapReduce 作业的执行可以使用以下命令运行:

$ bin/hadoop jar {HADOOP_HOME}/contrib/streaming/hadoop-streaming-1.0.3.jar 
 -input /ga/gadaat_mr.csv 
 -output /ga/output1 
 -file /usr/local/hadoop/ga/ga_mapper.R  
 -mapper ga_mapper.R 
 -file /usr/local/hadoop/ga/ga_ reducer.R 
 -reducer ga_reducer.R

从 R 或 RStudio 控制台执行 Hadoop 流作业

作为一个 R 用户，它将更适合从 R 控制台运行 Hadoop 流作业。这可以通过system命令完成:

system(paste("bin/hadoop jar”, “{HADOOP_HOME}/contrib/streaming/hadoop-streaming-1.0.3.jar",
 "-input /ga/gadata_mr.csv", 
 "-output /ga/output2", 
 "-file /usr/local/hadoop/ga/ga_mapper.R",
"-mapper ga_mapper.R", 
 "-file /usr/local/hadoop/ga/ga_reducer.R", 
 "-reducer ga_reducer.R"))

前面的命令类似于您已经在命令提示符中使用的命令，使用通用选项和流选项执行 Hadoop 流作业。

了解如何探索 MapReduce 应用的输出

在成功完成执行之后，是时候探索输出以检查生成的输出是否重要了。输出将与两个目录_logs和_SUCCESS一起生成。_logs将用于跟踪所有操作以及错误；_SUCCESS将仅在 MapReduce 作业成功完成时生成。

同样，命令可以通过以下两种方式触发:

  • 从命令提示符
  • 从控制台

探索命令提示符的输出

要在输出目录中列出生成的文件，将调用以下命令:

$ bin/hadoop dfs -cat /ga/output/part-* > temp.txt
$ head -n 40 temp.txt

检查输出的快照如下:

Exploring an output from the command prompt

探索来自 R 或 RStudio 控制台的输出

相同的命令可以与 R(带 RSTU 迪奥)控制台中的system方法一起使用。

dir <- system("bin/hadoop dfs -ls /ga/output",intern=TRUE)
out <- system("bin/hadoop dfs -cat /ga/output2/part-00000",intern=TRUE)

上述功能的屏幕截图如下所示:

Exploring an output from R or an RStudio console

了解 Hadoop MapReduce 脚本中使用的基本 R 函数

现在，我们将看到 Hadoop Mapper 和 Reducer 中用于数据处理的一些基本实用函数:

  • file:此功能用于创建与文件的连接，以进行读取或写入操作。也用于从/向stdin或stdout读写。该功能将在映射器和减速器阶段开始时使用。

    Con <- file("stdin", "r")

  • write:此功能用于将数据写入文件或标准输入。它将在映射器中设置键和值对后使用。

    write(paste(city,pagepath,sep="\t"),stdout())

  • print:此功能用于将数据写入文件或标准输入。它将在映射器中的键和值对准备就绪后使用。

    print(paste(city,pagepath,sep="\t"),stdout())

  • close:该功能可以是在读写操作完成后关闭与文件的连接。当所有过程完成后，可在关闭(conn)端与映射器和减速器一起使用。

  • stdin:这是输入对应的标准连接。stdin()功能是返回连接对象的文本模式连接。该功能将在 Mapper 和 Reducer 中使用。

    conn <- file("stdin", open="r")

  • stdout:这个是对应输出的标准连接。stdout()功能是文本模式连接，也返回对象。该功能将在 Mapper 和 Reducer 中使用。

    print(list(city.key, page.value),stdout())

## where city.key is key and page.value is value of that key

  • sink : sink驱动 R 输出到连接。如果有文件或流连接，输出将返回文件或流。这将在 Mapper 和 Reducer 中用于跟踪所有功能输出和错误。

    sink("log.txt")
k <- 1:5
for(i in 1:k){
print(paste("value of k",k))
}sink()
unlink("log.txt")

监控 Hadoop MapReduce 作业

reduce 阶段的一个小的语法错误导致了 MapReduce 作业的失败。Hadoop MapReduce 作业失败后，我们可以从 Hadoop MapReduce 管理页面跟踪问题，在该页面中，我们可以获得关于正在运行的作业以及已完成作业的信息。

如果作业失败，我们可以看到已完成/失败的映射和缩减作业的总数。单击失败的作业将提供这些特定数量的映射器或缩减器失败的原因。

另外，我们可以用 JobTracker 控制台查看那个正在运行的 MapReduce 作业的实时进度，如下图截图所示:

Monitoring the Hadoop MapReduce job

监控 Hadoop MapReduce 作业

通过该命令，我们可以通过使用以下命令指定特定 MapReduce 作业的输出目录来检查该作业的历史记录:

$ bin/hadoop job –history /output/location 

以下命令将打印 MapReduce 作业的详细信息、失败的作业以及终止作业的原因。

$ bin/hadoop job -history all /output/location 

前面的命令将打印成功的任务以及每个任务的任务尝试。

探索 HadoopStreaming R 包

HadoopStreaming 是由大卫·s·罗森伯格开发的 R 包。我们可以说这是一个简单的用于 MapReduce 脚本的框架。这也可以在没有 Hadoop 的情况下运行，以流式方式操作数据。我们可以将这个 R 包看作是一个 Hadoop MapReduce 发起者。对于任何不能在命令提示符下调用 Hadoop streaming 命令的分析师或开发人员来说，这个包将有助于快速运行 Hadoop MapReduce 作业。

该软件包的三个主要特性如下:

  • 分块数据读取:该包允许为 Hadoop 流进行分块数据读取和写入。该功能将克服内存问题。
  • 支持各种数据格式:该包允许以三种不同的数据格式读写数据。
  • Hadoop 流命令的强大实用程序:该包还允许用户为 Hadoop 流指定命令行参数。

该软件包主要设计有三个功能，用于高效读取数据:

  • hsTableReader
  • hsKeyValReader
  • hsLineReader

现在，让我们理解这些功能及其用例。之后我们将借助字数统计 MapReduce 作业了解这些功能。

理解 hsTableReader 功能

hsTableReader功能是为了读取表格格式的数据而设计的。这个函数假设有一个与文件建立的输入连接，所以它将检索整个行。它假设具有相同键的所有行都连续存储在输入文件中。

由于 Hadoop 流作业保证了 Mappers 的输出行在提供给 Reduce 之前会被排序，因此在 Hadoop 流 MapReduce 作业中不需要使用sort函数。当我们没有在 Hadoop 上运行这个时，我们需要在Mapper 函数被执行后明确地调用sort函数。

定义hsTableReader的功能:

hsTableReader(file="", cols='character',
 chunkSize=-1, FUN=print,
 ignoreKey=TRUE, singleKey=TRUE, skip=0,
 sep='\t', keyCol='key',
 FUN=NULL, ,carryMemLimit=512e6,
 carryMaxRows=Inf,
 stringsAsFactors=FALSE)

前面代码中的术语如下:

  • file:这是一个连接对象、流或字符串。
  • chunkSize:表示函数一次可以读取的最大行数。-1指一次所有的线路。
  • cols:这意味着要扫描的列名列表作为“what”参数。
  • skip:用于跳过前 n 个数据行。
  • FUN:该功能将使用用户输入的数据。
  • carryMemLimit:表示单键数值的最大内存限制。
  • carryMaxRows:这表示要考虑或从文件中读取的最大行数。
  • stringsAsFactors:定义字符串是否转换为因子(TRUE或FALSE)。

例如，文件中的数据:

# Loading libraries
Library("HadoopStreaming")
# Input data String with collection of key and values
str <- " key1\t1.91\nkey1\t2.1\nkey1\t20.2\nkey1\t3.2\nkey2\t1.2\nkey2\t10\nkey3\t2.5\nkey3\t2.1\nkey4\t1.2\n"cat(str)

前面代码的输出如下图所示:

Understanding the hsTableReader function

hsTableReader读取的数据为如下:

# A list of column names, as'what' arg to scan
cols = list(key='',val=0)

# To make a text connection
con <- textConnection(str, open = "r")
# To read the data with chunksize 3
hsTableReader(con,cols,chunkSize=3,FUN=print,ignoreKey=TRUE)

前面代码的输出如下图所示:

Understanding the hsTableReader function

理解 hsKeyValReader 功能

hsKeyValReader功能用于读取键值对格式的数据。该功能还使用chunkSize定义一次要读取的行数，每行由一个键串和值串组成。

hsKeyValReader(file = "", chunkSize = -1, skip = 0, sep = "\t",FUN = function(k, v) cat(paste(k, v))

该功能的术语类似hsTablereader()。

示例:

# Function for reading chunkwise dataset
printkeyval <- function(k,v) {cat('A chunk:\n')cat(paste(k,v,sep=': '),sep='\n')}
str <- "key1\tval1\nkey2\tval2\nkey3\tval3\n"
con <- textConnection(str, open = "r")

hsKeyValReader(con, chunkSize=1, FUN=printFn)

前面代码的输出如下图所示:

Understanding the hsKeyValReader function

理解 hsLineReader 功能

hsLineReader函数被设计为将整行作为字符串读取，而不执行数据解析操作。它从文件中反复读取chunkSize行数据，并将这些字符串的字符向量传递给FUN。

hsLineReader(file = "", chunkSize = 3, skip = 0, FUN = function(x) cat(x, sep = "\n"))

该功能的术语类似hsTablereader()。

示例:

str <- " This is HadoopStreaming!!\n here are,\n examples for chunk dataset!!\n in R\n  ?"

#  For defining the string as data source
con <- textConnection(str, open = "r")

# read from the con object
hsLineReader(con,chunkSize=2,FUN=print)

前面代码的输出如下图所示:

Understanding the hsLineReader function

您可以在http://cran . r-project . org/web/packages/Hadoop streaming/Hadoop streaming . pdf上获得这些方法以及其他现有方法的更多信息。

现在，我们将使用在 Hadoop 上运行的 Hadoop MapReduce 程序来实现上述数据读取方法。在某些情况下，键值对或数据行不会被送入机器内存；所以按块读取数据比改进机器配置更合适。

问题定义:

Hadoop 字数统计:我们已经知道什么是字数统计应用，我们将用字数统计的概念来实现上面给出的方法。这个 R 脚本是从 HadoopStreaming R 包中复制过来的，可以作为示例代码与 HadoopStreaming R 库发行版一起下载。

输入数据集:取自俄罗斯作家列夫·托尔斯泰《T2》《安娜·卡列尼娜》《T3》(小说)第一章。

r 脚本:这个部分包含映射器、减速器的代码，以及其余的配置参数。

文件:hsWordCnt.R

## Loading the library
library(HadoopStreaming)

## Additional command line arguments for this script (rest are default in hsCmdLineArgs)
spec = c('printDone','D',0,"logical","A flag to write DONE at the end.",FALSE)

opts = hsCmdLineArgs(spec, openConnections=T)

if (!opts$set) {
 quit(status=0)
}

# Defining the Mapper columns names
mapperOutCols = c('word','cnt')

# Defining the Reducer columns names
reducerOutCols = c('word','cnt')

# printing the column header for Mapper output
if (opts$mapcols) {
 cat( paste(mapperOutCols,collapse=opts$outsep),'\n', file=opts$outcon )
} 

# Printing the column header for Reducer output 
if (opts$reducecols) {
 cat( paste(reducerOutCols,collapse=opts$outsep),'\n', file=opts$outcon )
}

## For running the Mapper
if (opts$mapper) {
 mapper <- function(d) {
    words <- strsplit(paste(d,collapse=' '),'[[:punct:][:space:]]+')[[1]] # split on punctuation and spaces
    words <- words[!(words=='')]  # get rid of empty words caused by whitespace at beginning of lines
    df = data.frame(word=words)
    df[,'cnt']=1

# For writing the output in the form of key-value table format
hsWriteTable(df[,mapperOutCols],file=opts$outcon,sep=opts$outsep)
  }

## For chunk wise reading the Mapper output, to be feeded to Reducer hsLineReader(opts$incon,chunkSize=opts$chunksize,FUN=mapper)

## For running the Reducer
} else if (opts$reducer) {

  reducer <- function(d) {
    cat(d[1,'word'],sum(d$cnt),'\n',sep=opts$outsep)
  }
  cols=list(word='',cnt=0)  # define the column names and types (''-->string 0-->numeric)
  hsTableReader(opts$incon,cols,chunkSize=opts$chunksize,skip=opts$skip,sep=opts$insep,keyCol='word',singleKey=T, ignoreKey= F, FUN=reducer)
  if (opts$printDone) {
    cat("DONE\n");
  }
}

# For closing the connection corresponding to input
if (!is.na(opts$infile)) {
  close(opts$incon)
}

# For closing the connection corresponding to input
if (!is.na(opts$outfile)) {
  close(opts$outcon)
}

运行 Hadoop 流作业

由于这是一个 Hadoop 流作业，它将与前面执行的 Hadoop 流作业示例运行相同。对于这个例子，我们将使用一个 shell 脚本来执行runHadoop.sh文件，以运行 Hadoop 流。

设置系统环境变量:

#! /usr/bin/env bash
HADOOP="$HADOOP_HOME/bin/hadoop"   # Hadoop command

HADOOPSTREAMING="$HADOOP jar
$HADOOP_HOME/contrib/streaming/hadoop-streaming-1.0.3.jar" # change version number as appropriate

RLIBPATH=/usr/local/lib/R/site-library  # can specify additional R Library paths here

设置 MapReduce 作业参数:

INPUTFILE="anna.txt"
HFSINPUTDIR="/HadoopStreaming"
OUTDIR="/HadoopStreamingRpkg_output"

RFILE=" home/hduser/Desktop/HadoopStreaming/inst/wordCntDemo/ hsWordCnt.R"
#LOCALOUT="/home/hduser/Desktop/HadoopStreaming/inst/wordCntDemo/annaWordCnts.out"
# Put the file into the Hadoop file system
#$HADOOP fs -put $INPUTFILE $HFSINPUTDIR

删除现有的输出目录:

# Remove the directory if already exists (otherwise, won't run)
#$HADOOP fs -rmr $OUTDIR

使用通用和流式选项设计 Hadoop MapReduce 命令:

MAPARGS="--mapper" 
REDARGS="--reducer"
JOBARGS="-cmdenv R_LIBS=$RLIBPATH" # numReduceTasks 0
# echo $HADOOPSTREAMING -cmdenv R_LIBS=$RLIBPATH  -input $HFSINPUTDIR/$INPUTFILE -output $OUTDIR -mapper "$RFILE $MAPARGS" -reducer "$RFILE $REDARGS" -file $RFILE 

$HADOOPSTREAMING $JOBARGS   -input $HFSINPUTDIR/$INPUTFILE -output $OUTDIR -mapper "$RFILE $MAPARGS" -reducer "$RFILE $REDARGS" -file $RFILE

从 HDFS 提取输出到本地目录:

# Extract output
./$RFILE --reducecols > $LOCALOUT
$HADOOP fs -cat $OUTDIR/part* >> $LOCALOUT

执行 Hadoop 流作业

我们现在可以通过执行命令runHadoop.sh来执行 Hadoop 流作业。要执行此操作，我们需要设置用户权限。

sudo chmod +x runHadoop.sh

通过以下命令执行:

./runHadoop.sh

最后，它将执行整个 Hadoop 流作业，然后将输出复制到本地目录。

总结

我们已经学习了大多数集成 R 和 Hadoop 来执行数据操作的方法。在下一章中，我们将了解数据分析周期，以便在 R 和 Hadoop 的帮助下解决现实世界的数据分析问题。

五、使用 R 和 Hadoop 学习数据分析

在前面的章节中，我们学习了 R 和 Hadoop 的安装、配置和集成。

在这一章中，我们将学习如何在集成的 R 和 Hadoop 环境中执行数据分析操作。由于本章是为数据分析而设计的，我们将通过有效的数据分析周期来理解这一点。

在本章中，我们将了解:

  • 了解数据分析项目生命周期
  • 了解数据分析问题

了解数据分析项目生命周期

在处理数据分析项目时，有一些固定的任务应该遵循，以获得预期的输出。因此，在这里，我们将构建一个数据分析项目周期，这将是一套标准的数据驱动流程，以有效地将数据引向见解。项目生命周期中定义的数据分析流程应遵循使用输入数据集有效实现目标的顺序。该数据分析过程可能包括识别数据分析问题、设计和收集数据集、数据分析和数据可视化。

数据分析项目生命周期阶段如下图所示:

Understanding the data analytics project life cycle

让我们对执行数据分析的这些阶段有所了解。

识别问题

如今，业务分析趋势通过在网络数据集上执行数据分析来改变，以发展业务。由于他们的数据的规模日益增加，他们的分析应用需要可扩展，以便从他们的数据集收集见解。

借助网络分析，我们可以解决业务分析问题。假设我们有一个大型电子商务网站，我们想知道如何增加业务。我们可以根据受欢迎程度将网站的重要页面分为高、中、低三类来识别。基于这些受欢迎的页面、它们的类型、它们的流量来源和它们的内容，我们将能够决定通过改善网络流量和内容来改善业务的路线图。

设计数据需求

为了针对特定问题执行数据分析，它需要来自相关领域的数据集。基于域和问题规范，可以根据问题定义决定数据源；可以定义这些数据集的数据属性。

例如，如果我们要执行社交媒体分析(问题规范)，我们使用的数据源是脸书或推特。为了识别用户特征，我们需要用户简档信息、喜好和帖子作为数据属性。

数据预处理

在数据分析中，我们不会一直使用相同的数据源、数据属性、数据工具和算法，因为它们都不会使用相同格式的数据。这将提高数据操作的性能，例如数据清理、数据聚合、数据扩充、数据排序和数据格式化，以支持的格式向所有数据工具以及将在数据分析中使用的算法提供数据。

简单来说，预处理就是在将数据提供给算法或工具之前，先进行数据操作，将数据翻译成固定的数据格式。然后，数据分析过程将以该格式化数据作为输入开始。

在大数据的情况下，数据集需要格式化并上传到 Hadoop 分布式文件系统 ( HDFS )中，并由 Hadoop 集群中具有 Mappers 和 Reducers 的各个节点进一步使用。

对数据进行分析

在数据以数据分析算法所需的格式可用后，将执行数据分析操作。执行数据分析操作是为了从数据中发现有意义的信息，以便利用数据挖掘概念对业务做出更好的决策。它可以对商业智能使用描述性或预测性分析。

分析可以通过各种机器学习以及自定义算法概念来执行，例如回归、分类、聚类和基于模型的推荐。对于大数据，通过将其数据分析逻辑转换为将在 Hadoop 集群上运行的 MapReduce 作业，可以将相同的算法转换为在 Hadoop 集群上运行的 MapReduce 算法。这些模型需要通过机器学习概念的各种评估阶段来进一步评估和改进。改进或优化的算法可以提供更好的见解。

可视化数据

数据可视化用于显示数据分析的输出。可视化是一种表示数据见解的交互方式。这可以通过各种数据可视化软件以及 R 包来实现。r 有多种用于数据集可视化的包。它们如下:

使用 R 可视化的一些流行示例如下:

  • Plots for facet scales (ggplot): The following figure shows the comparison of males and females with different measures; namely, education, income, life expectancy, and literacy, using ggplot:

    Visualizing data

  • Dashboard charts: This is an rCharts type. Using this we can build interactive animated dashboards with R.

    Visualizing data

了解数据分析问题

在本节中，我们包括了三个实际的数据分析问题，这些问题与使用 R 和 Hadoop 技术的数据驱动活动的不同阶段有关。这些数据分析问题的定义旨在让读者了解如何利用函数的分析能力、R 包和 Hadoop 的计算能力来完成大数据分析。

数据分析问题定义如下:

  • 探索网页分类
  • 计算股票市场的变化频率
  • 推土机蓝皮书销售价格预测(案例研究)

探索网页分类

该数据分析问题旨在识别网站网页的类别，根据页面的访问次数，可以将的受欢迎程度分类为高、中或低(常规)。在设计数据分析生命周期的数据需求阶段时，我们将看到如何从 谷歌分析收集这些类型的数据。

Exploring web pages categorization

识别问题

由于这是一个网络分析问题，该问题的目标是确定为网站设计的网页的重要性。基于这些信息，可以改进或增加较低流行页面的内容、设计或访问量。

设计数据需求

在这个部分，我们将研究数据分析问题的数据需求和数据收集。首先，让我们看看如何针对这个问题实现对数据的需求。

由于这是一个网络分析问题，我们将使用谷歌分析数据源。要从谷歌分析中检索这些数据，我们需要一个现有的谷歌分析账户，上面存储着网络流量数据。为了增加知名度，我们将要求所有网页的访问信息。此外，在谷歌分析中，还有许多其他关于维度和指标的属性。

了解所需的谷歌分析数据属性

要从谷歌分析中提取的数据集的标题格式如下:

date, source, pageTitle, pagePath
  • date:这是网页被访问的日期
  • source:这是对网页的引用
  • pageTitle:这是网页的标题
  • pagePath:这是网页的 URL
收集数据

当我们要从谷歌分析中提取数据时，我们需要使用RGoogleAnalytics，这是一个用于在 R 中提取谷歌分析数据集的 R 库。要提取数据，您需要在 R 中安装这个插件。然后您就可以使用它的功能。

以下是谷歌分析提取过程的代码:

# Loading the RGoogleAnalytics library
require("RGoogleAnalyics")

# Step 1\. Authorize your account and paste the access_token
query <- QueryBuilder()
access_token <- query$authorize()

# Step 2\. Create a new Google Analytics API object
ga <- RGoogleAnalytics()

# To retrieve profiles from Google Analytics
ga.profiles <- ga$GetProfileData(access_token)

# List the GA profiles 
ga.profiles

# Step 3\. Setting up the input parameters
profile <- ga.profiles$id[3] 
startdate <- "2010-01-08"
enddate <- "2013-08-23"
dimension <- "ga:date,ga:source,ga:pageTitle,ga:pagePath"
metric <- "ga:visits"
sort <- "ga:visits"
maxresults <- 100099

# Step 4\. Build the query string, use the profile by setting its index value
query$Init(start.date = startdate,
           end.date = enddate,
           dimensions = dimension,
           metrics = metric,

           max.results = maxresults,
           table.id = paste("ga:",profile,sep="",collapse=","),
           access_token=access_token)

# Step 5\. Make a request to get the data from the API
ga.data <- ga$GetReportData(query)

# Look at the returned data
head(ga.data)
write.csv(ga.data,"webpages.csv", row.names=FALSE)

之前的文件将随章节内容一起提供下载。

数据预处理

现在，我们在一个 CSV 文件中提供了谷歌分析的原始数据。在提供给 MapReduce 算法之前，我们需要处理这个数据。

需要对数据集进行两项主要更改:

  • 查询参数需要从pagePath栏中删除，如下所示:

    pagePath <- as.character(data$pagePath)
pagePath <- strsplit(pagePath,"\\?")
pagePath <- do.call("rbind", pagePath)
pagePath <- pagePath [,1]

  • 新的 CSV 文件需要创建如下:

    data  <- data.frame(source=data$source, pagePath=d,visits =)
write.csv(data, "webpages_mapreduce.csv" , row.names=FALSE)

对数据进行分析

为了对网站页面进行分类，我们将构建并运行集成了 R 和 Hadoop 的 MapReduce 算法。正如在第 2 章、编写 Hadoop MapReduce 程序中已经讨论过的，有时我们需要使用多个 Mappers 和 Reduce 来执行数据分析；这意味着使用链式 MapReduce 作业。

在链接映射缩减作业的情况下，多个映射器和缩减器可以通过这样一种方式进行通信，即第一个作业的输出将作为输入分配给第二个作业。下图描述了 MapReduce 的执行顺序:

Performing analytics over data

链接 MapReduce

现在，让我们从执行分析的编程任务开始:

  1. 通过设置 Hadoop 变量并加载 RHadoop 库的rmr2和rhdfs包来初始化:

    # setting up the Hadoop variables need by RHadoop
Sys.setenv(HADOOP_HOME="/usr/local/hadoop/")
Sys.setenv(HADOOP_CMD="/usr/local/hadoop/bin/hadoop")

# Loading the RHadoop libraries rmr2 and rhdfs
library(rmr2)
library(rhdfs)

# To initializing hdfs
hdfs.init()

  2. 将数据集上传至 HDFS:

    # First uploading the data to R console,
webpages <- read.csv("/home/vigs/Downloads/webpages_mapreduce.csv")

# saving R file object to HDFS,
webpages.hdfs <- to.dfs(webpages)

现在我们将看到这些分析的 Hadoop MapReduce 作业 1 的开发。我们将把这项工作分为映射器和缩减器。因为有两个映射减少作业，所以将有两个映射器和减少器。还要注意，在这里，我们只需要为所有映射器和缩减器的两个作业创建一个文件。映射器和缩减器将通过定义它们各自的功能来建立。

让我们看看 MapReduce 作业 1。

  • 映射器 1 :代码如下:

    mapper1 <- function(k,v) {

 # To storing pagePath column data in to key object
 key <- v[2]

 # To store visits column data into val object
 Val <- v[3]

 # emitting key and value for each row
 keyval(key, val)
}
totalvisits <- sum(webpages$visits)

  • 减速器 1 :代码如下:

    reducer1 <- function(k,v) {

  # Calculating percentage visits for the specific URL
  per <- (sum(v)/totalvisits)*100
  # Identify the category of URL
  if (per <33 )
 {
val <- "low"
}
 if (per >33 && per < 67)
 {
 val <- "medium"
 }
 if (per > 67)
 {
 val <- "high"
 }

 # emitting key and values
 keyval(k, val)
}

  • Output of MapReduce job 1: The intermediate output for the information is shown in the following screenshot:

    Performing analytics over data

上一个截图中的输出仅用于获取关于这个 MapReduce 作业 1 的输出的信息。这可以被认为是中间输出，其中从整个数据集中仅考虑了 100 个数据行来提供输出。在这些行中，有 23 个 URL 是唯一的；所以输出提供了 23 个网址。

让我们看看 Hadoop MapReduce 作业 2:

  • 映射器 2 :代码如下:

    #Mapper:
mapper2 <- function(k, v) {

# Reversing key and values and emitting them 
 keyval(v,k)
}

  • Reducer 2: The code for this is as follows:

    key <- NA
val <- NULL
# Reducer:
reducer2  <-  function(k, v) {

# for checking whether key-values are already assigned or not.
 if(is.na(key)) {
 key <- k
 val <- v
  } else {
   if(key==k) {
 val <- c(val,v)
  } else{
   key <- k
   val <- v
  }
 }
# emitting key and list of values 
keyval(key,list(val))
}

    类型

    在执行 MapReduce 作业之前，请启动所有 Hadoop 守护程序，并通过hdfs.init()方法检查 HDFS 连接。如果您的 Hadoop 守护程序尚未启动，您可以通过$hduser@ubuntu :~ $HADOOP_HOME/bin/start-all.sh启动它们。

一旦我们准备好映射器和缩减器的逻辑，MapReduce 作业就可以通过rmr2包的 MapReduce 方法来执行。这里我们已经开发了多个 MapReduce 作业，因此我们需要使用所需的参数调用mapreduce函数中的mapreduce函数。

下图显示了调用链式 MapReduce 作业的命令:

Performing analytics over data

以下是从 HDFS 检索生成的输出的命令:

from.dfs(output)

执行 Hadoop MapReduce 时，会通过终端打印执行日志输出，以达到监控的目的。我们将通过将 MapReduce 作业 1 和 MapReduce 作业 2 分成不同的部分来理解它们。

MapReduce 作业 1 的详细信息如下:

  • Tracking the MapReduce job metadata: With this initial portion of log, we can identify the metadata for the Hadoop MapReduce job. We can also track the job status with the web browser by calling the given Tracking URL.

    Performing analytics over data

  • Tracking status of Mapper and Reducer tasks: With this portion of log, we can monitor the status of the Mapper or Reducer task being run on Hadoop cluster to get details such as whether it was a success or a failure.

    Performing analytics over data

  • Tracking HDFS output location: Once the MapReduce job is completed, its output location will be displayed at the end of logs.

    Performing analytics over data

对于 MapReduce 作业 2。

  • Tracking the MapReduce job metadata: With this initial portion of log, we can identify the metadata for the Hadoop MapReduce job. We can also track the job status with the web browser by calling the given Tracking URL.

    Performing analytics over data

  • Tracking status of the Mapper and Reducer tasks: With this portion of log, we can monitor the status of the Mapper or Reducer tasks being run on the Hadoop cluster to get the details such as whether it was successful or failed.

    Performing analytics over data

  • Tracking HDFS output location: Once the MapReduce job is completed, its output location will be displayed at the end of the logs.

    Performing analytics over data

这个链式 MapReduce 作业的输出存储在 HDFS 的一个位置，可以通过以下命令检索:

from.dfs(output)

下图显示了对前面命令的响应(仅输出数据集的前 1000 行):

Performing analytics over data

可视化数据

我们使用这三个类别收集了网页分类输出。我认为我们能做的最好的事情就是简单地列出网址。但是如果我们有更多的信息，比如来源，我们可以将网页表示为一个图的节点，当用户跟随链接时，通过有向边的流行度来着色。这可以带来更丰富的见解。

计算股市变化的频率

这个数据分析 MapReduce 问题是为了计算股市变化的频率而设计的。

识别问题

由于这是一个典型的股票市场数据分析问题，它将计算股票市场的一个特定符号过去变化的频率，例如傅立叶变换 。基于这些信息，投资者可以获得更多关于不同时期变化的见解。所以这个分析的目标是计算百分比变化的频率。

Identifying the problem

设计数据需求

对于这个股市分析，我们将使用雅虎！财务作为输入数据集。我们需要检索特定符号的股票信息。为了检索这些数据，我们将使用雅虎！具有以下参数的应用编程接口:

  • 从月份开始
  • 从那天开始
  • 从年
  • 到月
  • 今天
  • 到年
  • 标志

类型

更多关于这个 API 的信息，请访问http://developer.yahoo.com/finance/。

数据预处理

为了对提取的数据集执行分析，我们将使用 R 来触发以下命令:

stock_BP <- read.csv("http://ichart.finance.yahoo.com/table.csv?s=BP")

或者您也可以通过终端下载:

wget http://ichart.finance.yahoo.com/table.csv?s=BP
#exporting to csv file

write.csv(stock_BP,"table.csv", row.names=FALSE)

然后通过为此创建一个特定的 Hadoop 目录将其上传到 HDFS:

# creating /stock directory in hdfs
bin/hadoop dfs -mkdir /stock

# uploading table.csv to hdfs in /stock directory
bin/hadoop dfs -put /home/Vignesh/downloads/table.csv /stock/

对数据进行分析

为了执行数据分析操作，我们将使用带有 R 和 Hadoop 的流(没有HadoopStreaming包)。因此，这个 MapReduce 作业的开发可以在没有任何 RHadoop 集成库/包的情况下完成。

在这个 MapReduce 作业中，我们在不同的 R 文件中定义了 Map 和 Reduce，以提供给 Hadoop 流功能。

  • 文件夹 ： stock_mapper.R

    #! /usr/bin/env/Rscript
# To disable the warnings
options(warn=-1)
# To take input the data from streaming
input <- file("stdin", "r")

# To reading the each lines of documents till the end
while(length(currentLine <-readLines(input, n=1, warn=FALSE)) > 0)
{

# To split the line by "," seperator
fields <- unlist(strsplit(currentLine, ","))

# Capturing open column value
 open <- as.double(fields[2])

# Capturing close columns value
 close <- as.double(fields[5])

# Calculating the difference of close and open attribute
 change <- (close-open)

# emitting change as key and value as 1
write(paste(change, 1, sep="\t"), stdout())
}

close(input)

  • 减速器 : stock_reducer.R

    #! /usr/bin/env Rscript
stock.key <- NA
stock.val <- 0.0

conn <- file("stdin", open="r")
while (length(next.line <- readLines(conn, n=1)) > 0) {
 split.line <- strsplit(next.line, "\t")
 key <- split.line[[1]][1]
 val <- as.numeric(split.line[[1]][2])
 if (is.na(current.key)) {
 current.key <- key
 current.val <- val
 }
 else {
 if (current.key == key) {
current.val <- current.val + val
}
else {
write(paste(current.key, current.val, sep="\t"), stdout())
current.key <- key
current.val<- val
}
}
}
write(paste(current.key, current.val, sep="\t"), stdout())
close(conn)

从下面的代码中，我们在没有安装或使用任何 R 库/包的情况下在 R 中运行 MapReduce。R 中有一个system()方法可以将 R 控制台中的系统命令激发到中，帮助我们指导 R 中 Hadoop 作业的激发。它还将提供命令进入 R 控制台的休息。

# For locating at Hadoop Directory
system("cd $HADOOP_HOME")

# For listing all HDFS first level directorysystem("bin/hadoop dfs -ls /")

# For running Hadoop MapReduce with streaming parameters
system(paste("bin/hadoop jar 
/usr/local/hadoop/contrib/streaming/hadoop-streaming-1.0.3.jar ",

" -input /stock/table.csv",
" -output /stock/outputs",
" -file /usr/local/hadoop/stock/stock_mapper.R",
" -mapper /usr/local/hadoop/stock/stock_mapper.R",
" -file /usr/local/hadoop/stock/stock_reducer.R",
" -reducer /usr/local/hadoop/stock/stock_reducer.R"))

# For storing the output of list command 
dir <- system("bin/hadoop dfs -ls /stock/outputs", intern=TRUE)
dir

# For storing the output from part-oooo (output file)
out <- system("bin/hadoop dfs -cat /stock/outputs/part-00000", intern=TRUE)

# displaying Hadoop MapReduce output data out

您也可以通过终端运行相同的程序:

bin/hadoop jar /usr/local/hadoop/contrib/streaming/hadoop-streaming-1.0.3.jar \

 -input /stock/table.csv \
 -output /stock/outputs\
 -file /usr/local/hadoop/stock/stock_mapper.R \
 -mapper /usr/local/hadoop/stock/stock_mapper.R \
 -file /usr/local/hadoop/stock/stock_reducer.R \
 -reducer /usr/local/hadoop/stock/stock_reducer.R

运行该程序时，您的 R 控制台或终端的输出将如下面的截图所示，在此帮助下，我们可以监控 Hadoop MapReduce 作业的状态。在这里，我们将依次看到它们的分割部分。请注意我们已经将输出的日志分成几部分，以帮助您更好地理解它们。

MapReduce 日志输出包含(从终端运行时):

  • With this initial portion of log, we can identify the metadata for the Hadoop MapReduce job. We can also track the job status with the web browser, by calling the given Tracking URL. This is how the MapReduce job metadata is tracked.

    Performing analytics over data

  • With this portion of log, we can monitor the status of the Mapper or Reducer tasks being run on the Hadoop cluster to get the details like whether it was successful or failed. This is how we track the status of the Mapper and Reducer tasks.

    Performing analytics over data

  • Once the MapReduce job is completed, its output location will be displayed at the end of the logs. This is known as tracking the HDFS output location.

    Performing analytics over data

  • 从终端，可以使用以下命令调用 Hadoop MapReduce 程序的输出:

    bin/hadoop dfs -cat /stock/outputs/part-00000

  • 您的 MapReduce 程序输出的标题如下所示:

    change    frequency

  • The following figure shows the sample output of MapReduce problem:

    Performing analytics over data

可视化数据

如果我们用 r 中的各种图形可视化我们的输出，我们可以得到更多的见解。在这里，我们试图借助ggplot2包可视化输出。

Visualizing data

从前面的图中，我们可以很快识别出，大部分时间股价都是从 0 到 1.5 左右变化的。所以，历史上股票的价格走势在投资的时候会有帮助。

生成该图所需的代码如下:

# Loading ggplot2 library
library(ggplot2);

# we have stored above terminal output to stock_output.txt file

#loading it to R workspace
myStockData <- read.delim("stock_output.txt", header=F, sep="", dec=".");

# plotting the data with ggplot2 geom_smooth function
ggplot(myStockData, aes(x=V1, y=V2)) + geom_smooth() + geom_point();

在下一部分中，我们已经包括了关于如何使用 R 和 Hadoop 为 Kaggle data 竞赛执行大数据分析的案例研究。

推土机蓝皮书销售价格预测——案例分析

这是一个预测重型设备拍卖价格的案例研究，为推土机创造蓝皮书。

识别问题

在这个的例子中，我包含了 Cloudera 数据科学家关于如何对大数据集进行重采样的案例研究，并应用了带有 R 和 Hadoop 的随机森林模型。在这里，我考虑了 Kaggle 推土机蓝皮书，以了解大数据问题定义的类型。在这里，本次竞赛的目标是根据使用情况、设备类型和配置，预测特定重型设备在使用拍卖中的销售价格。这个解决方案是由尤里·拉尔森(Cloudera 的数据科学家)提供的。所提供的数据包含关于拍卖结果公布、使用和设备配置的信息。

对大数据集建模并将其划分为更小的数据集是一个技巧。在该数据集上拟合模型是一种传统的机器学习技术，例如随机森林或打包。随机森林可能有两个原因:

  • 大型数据集通常位于一个集群中，因此任何操作都有一定程度的并行性。独立的模型适合包含不同初始数据子集的独立节点。
  • 即使您可以使用整个初始数据集来拟合单个模型，事实证明，通过使用数据子集来拟合多个较小模型的集成方法通常优于单个模型。事实上，用 1 亿个数据点拟合单个模型的性能可能比仅用 10M 个数据点拟合几个模型的性能差(因此较小的总数据优于较大的总数据)。

通过替换进行采样是从初始数据集进行采样的最流行方法，用于产生模型拟合的样本集合。这种方法相当于从多项式分布中进行采样，其中选择任何单个输入数据点的概率在整个数据集中是一致的。

类型

Kaggle 是一个大数据平台，来自世界各地的数据科学家竞相解决由数据驱动型组织托管的大数据分析问题。

设计数据需求

对于这场比赛，Kaggle 提供了真实世界的数据集，包括大约 400，000 个训练数据点。每个数据点代表销售的各种属性、推土机的配置和销售价格。为了找到预测销售价格的地方，需要实现随机森林回归模型。

注

本次卡格尔比赛的参考链接是http://www.kaggle.com/c/bluebook-for-bulldozers。您可以查看数据、信息、论坛和排行榜，还可以探索其他一些大数据分析竞赛，并参加这些竞赛来评估您的数据分析技能。

我们选择这个模型是因为我们对从大数据集的随机集合中预测数值形式的销售价格感兴趣。

数据集以下列数据文件的形式提供:

|

文件名

|

描述格式(大小)

|
| --- | --- |
| Train | 这是一个包含 2011 年数据的训练集。 |
| Valid | 这是一个验证集，包含 2012 年 1 月 1 日至 2012 年 4 月 30 日的数据。 |
| Data dictionary | 这是训练数据集变量的元数据。 |
| Machine_Appendix | 这包含给定机器的正确制造年份，以及制造商、型号和产品类别的详细信息。 |
| Test | 这将测试数据集。 |
| random_forest_benchmark_test | 这是主机提供的基准解决方案。 |

类型

如果你想学习和练习大数据分析，你可以通过参加卡格尔数据竞赛从卡格尔数据源获取大数据集。这些包含来自全球各行业的各个领域的数据集。

数据预处理

要对所提供的卡格尔数据集进行分析，我们需要建立一个预测模型。为了预测拍卖的销售价格，我们将在提供的数据集上拟合模型。但是数据集提供了不止一个文件。因此，我们将合并它们，并执行数据扩充，以获取更有意义的数据。我们将从Train.csv和Machine_Appendix.csv建立一个模型，以便更好地预测销售价格。

以下是需要对数据集执行的数据预处理任务:

# Loading Train.csv dataset which includes the Sales as well as machine identifier data attributes.

transactions <- read.table(file="~/Downloads/Train.csv",
header=TRUE,
sep=",",
quote="\"",
row.names=1,
fill=TRUE,
colClasses=c(MachineID="factor",
 ModelID="factor",
datasource="factor",
YearMade="character",
SalesID="character",
auctioneerID="factor",
UsageBand="factor",
saledate="custom.date.2",
Tire_Size="tire.size",
Undercarriage_Pad_Width="undercarriage",
Stick_Length="stick.length"),
na.strings=na.values)

# Loading Machine_Appendix.csv for machine configuration information

machines <- read.table(file="~/Downloads/Machine_Appendix.csv",
header=TRUE,
sep=",",
quote="\"",
fill=TRUE,
colClasses=c(MachineID="character",
ModelID="factor",
fiManufacturerID="factor"),
na.strings=na.values)

# Updating the values to numeric 
# updating sale data number
transactions$saledatenumeric <- as.numeric(transactions$saledate)
transactions$ageAtSale <- as.numeric(transactions$saledate - as.Date(transactions$YearMade, format="%Y"))

transactions$saleYear <- as.numeric(format(transactions$saledate, "%Y"))

# updating the month of sale from transaction
transactions$saleMonth <- as.factor(format(transactions$saledate, "%B"))

# updating the date of sale from transaction
transactions$saleDay <- as.factor(format(transactions$saledate, "%d"))

# updating the day of week of sale from transaction
transactions$saleWeekday <- as.factor(format(transactions$saledate, "%A"))

# updating the year of sale from transaction
transactions$YearMade <- as.integer(transactions$YearMade)

# deriving the model price from transaction
transactions$MedianModelPrice <- unsplit(lapply(split(transactions$SalePrice, 
transactions$ModelID), median), transactions$ModelID)

# deriving the model count from transaction
transactions$ModelCount <- unsplit(lapply(split(transactions$SalePrice, transactions$ModelID), length), transactions$ModelID)

# Merging the transaction and machine data in to dataframe 
training.data <- merge(x=transactions, y=machines, by="MachineID")

# write denormalized data out
write.table(x=training.data,
file="~/temp/training.csv",
sep=",",
quote=TRUE,
row.names=FALSE,
eol="\n",
col.names=FALSE)
# Create poisson directory at HDFS
bin/hadoop dfs -mkdir /poisson

# Uploading file training.csv at HDFS
bin/hadoop dfs -put ~/temp/training.csv /poisson/

对数据进行分析

当我们要对采样数据集进行分析时，我们需要了解需要采样多少数据集。

对于随机抽样，我们考虑了三个模型参数，如下所示:

  • 我们的初始训练集中有 N 个数据点。这是非常大的(106-109)，并且分布在 HDFS 集群上。
  • 我们将为集成分类器训练一组 M 个不同的模型。
  • M 个模型中的每一个都将拟合 K 个数据点，其中通常 K << N(例如，K 可以是 n 的 1-10%)。

我们有 N 个训练数据集，这些数据集是固定的，通常不在我们的控制范围内。由于我们将通过泊松采样来处理这个问题，我们需要定义要在随机森林模型中消耗的输入向量的总数。

有三种情况需要考虑:

  • KM < N :在这种情况下，我们没有使用我们可以获得的全部数据
  • KM = N :在这种情况下，我们可以精确地划分我们的数据集，以产生完全独立的样本
  • KM > N :在这种情况下，我们必须用替换数据对我们的一些数据进行重新采样

下一节中描述的泊松采样方法在同一个框架中处理所有三种情况。但是，请注意，对于 KM = N 的情况，它不会对数据进行分区，而只是对其进行重新采样。

理解泊松近似重采样

广义线性模型是一般线性模型的扩展。泊松回归是广义模型的一种情况。因变量服从泊松分布。

泊松采样将在 MapReduce 任务的地图上运行，因为它是针对输入数据点进行的。这并不能保证每个数据点都会被考虑到模型中，这比全数据集的多项式重采样要好。但是它将保证通过使用 N 个训练输入点来生成独立的样本。

这里，下图显示了在泊松采样中可以检索到的缺失数据集的数量，其函数为 KM/N:

Understanding Poisson-approximation resampling

灰色的线表示 KM=N 的值，现在我们来看看 MapReduce 算法的伪代码。我们使用了三个参数:N、M 和 K，其中 K 是固定的。我们使用 T=K/N 来预先消除对 N 值的需要。

  • 采样参数示例:这里我们用一个伪代码实现前面的逻辑。我们将从定义两个模型输入参数frac.per.model和num.models开始，其中frac.per.model用于定义可以使用的完整数据集的分数，num.models用于定义将从数据集拟合多少个模型。

    T = 0.1  # param 1: K / N-average fraction of input data in each model 10%

M = 50   # param 2: number of models

  • 映射器的逻辑:映射器将被设计用于通过数据角力生成整个数据集的样本。

    def map(k, v):
// for each input data point
    for i in 1:M  
    // for each model
        m = Poisson(T)  
    // num times curr point should appear in this sample
        if m > 0
            for j in 1:m
   // emit current input point proper num of times
                emit (i, v)

  • 减速器的逻辑:减速器会取一个数据样本作为输入，在上面拟合随机森林模型。

    def reduce(k, v):
    fit model or calculate statistic with the sample in v

用 RHadoop 拟合随机森林

在机器学习中，拟合一个模型意味着将最佳线拟合到我们的数据中。拟合模型可以分为几种类型，即欠拟合、过拟合和正拟合。在欠拟合和过拟合的情况下，存在高偏差(交叉验证和训练误差高)和高方差(交叉验证误差高但训练误差低)影响的机会，这是不好的。我们通常会在数据集上拟合模型。

以下是通过三种拟合类型在数据集上拟合模型的图表:

  • Under fitting: In this cross validation and training errors are high

    Fitting random forests with RHadoop

  • Normal fitting: In this cross-validation and training errors are normal

    Fitting random forests with RHadoop

  • Over fitting: In this the cross-validation error is high but training error is low

    Fitting random forests with RHadoop

我们将使用机器学习的随机森林技术对数据拟合模型。这是一种递归分区方法，特别适合小型和大型问题。它涉及分类(或回归)树的集合(或集合)，这些树是在数据的随机子集上计算的，对每个分类树中的每个分割使用随机限制和选择的预测器的子集。

此外，分类/回归树的集合的结果已经被用来产生更好的预测，而不是仅仅使用一个分类树的结果。

我们现在将使用 RHadoop 实现泊松采样策略。我们将从设置参数的全局值开始:

#10% of input data to each sample on avg
frac.per.model <- 0.1  
num.models <- 50

让我们看看如何使用 RHadoop 按照伪代码中的规范实现映射器。

  • Mapper is implemented in the the following manner:

    poisson.subsample <- function(k, input) {
  # this function is used to generate a sample from the current block of data
  generate.sample <- function(i) {
    # generate N Poisson variables
    draws <- rpois(n=nrow(input), lambda=frac.per.model)
    # compute the index vector for the corresponding rows,
    # weighted by the number of Poisson draws
    indices <- rep((1:nrow(input)), draws)
    # emit the rows; RHadoop takes care of replicating the key appropriately
    # and rbinding the data frames from different mappers together for the
    # reducer
    keyval(i, input[indices, ])
  }

  # here is where we generate the actual sampled data
  c.keyval(lapply(1:num.models, generate.sample))
}

    因为我们使用的是 R，所以在收集的样本数据集上用随机森林模型拟合模型是很棘手的。

  • 减速器通过以下方式实现:

    # REDUCE function
fit.trees <- function(k, v) {
  # rmr rbinds the emitted values, so v is a dataframe
  # note that do.trace=T is used to produce output to stderr to keep the reduce task from timing out
  rf <- randomForest(formula=model.formula,
                        data=v,
                        na.action=na.roughfix,
                        ntree=10,
                        do.trace=FALSE)

 # rf is a list so wrap it in another list to ensure that only
 # one object gets emitted. this is because keyval is vectorized
  keyval(k, list(forest=rf))
}

  • To fit the model, we need model.formula, which is as follows:

    model.formula <- SalePrice ~ datasource + auctioneerID + YearMade + saledatenumeric + ProductSize + ProductGroupDesc.x + Enclosure + Hydraulics + ageAtSale + saleYear + saleMonth + saleDay + saleWeekday + MedianModelPrice + ModelCount + MfgYear

    SalePrice定义为响应变量，其余定义为随机森林模型的预测变量。

    类型

    R 的随机森林模型不支持等级大于 32 的因子。

  • The MapReduce job can be executed using the following command:

    mapreduce(input="/poisson/training.csv",
 input.format=bulldozer.input.format,
 map=poisson.subsample,
 reduce=fit.trees,
 output="/poisson/output")

    由此产生的树木在/poisson/output被倾倒在 HDFS。

  • 最后，我们可以加载树，合并它们，并使用它们来分类新的测试点:

    mraw.forests <- values(from.dfs("/poisson/output"))
forest <- do.call(combine, raw.forests)

50 个样本中的每一个都生成了一个包含 10 棵树的随机森林，因此最终的随机森林是 500 棵树的集合，以分布式方式分布在一个 Hadoop 集群上。

注

完整的源文件可在官方 Cloudera 博客上获得，网址为 http://blog . Cloudera . com/blog/2013/02/如何与 hadoop 上的 r 并行从大数据集重新采样/ 。

希望我们已经学习了一种可扩展的方法，通过对多项式采样使用泊松近似来训练集成分类器或以并行方式自举。

总结

在本章中，我们学习了如何在一个 R 和 Hadoop 集成的环境中，通过各种数据驱动的活动来执行大数据分析。

在下一章中，我们将进一步了解如何使用 R 和 Hadoop 来执行机器学习技术。

六、使用机器学习理解大数据分析

在本章中，我们将学习不同的机器学习技术，这些技术可以与 R 和 Hadoop 一起使用，借助以下几点来执行大数据分析:

  • 机器学习导论
  • 机器学习算法的类型
  • 监督机器学习算法
  • 无监督机器学习算法
  • 推荐算法

机器学习入门

机器学习是人工智能的一个分支，它允许我们在没有明确编程的情况下使我们的应用变得智能。机器学习概念用于使应用能够从可用的数据集做出决策。机器学习和数据挖掘的结合可用于开发垃圾邮件检测器、自动驾驶汽车、语音识别、人脸识别和在线交易欺诈活动检测。

有许多流行的组织正在使用机器学习算法来使他们的服务或产品理解用户的需求，并根据他们的行为提供服务。谷歌有自己的智能网络搜索引擎，它提供排名第一的搜索，谷歌邮件中的垃圾邮件分类，谷歌新闻中的新闻标签，以及推荐系统的亚马逊。有许多开源框架可用于开发这些类型的应用/框架，例如 R、Python、Apache Mahout 和 Weka。

机器学习算法的类型

智能系统开发有三种不同类型的机器学习算法:

  • 监督机器学习算法
  • 无监督机器学习算法
  • 推荐系统

在这一章中，我们将讨论众所周知的分类、回归和聚类的业务问题，以及如何在 Hadoop 上执行这些机器学习技术来克服内存问题。

如果您加载一个无法装入机器内存的数据集，并尝试运行它，预测分析将抛出一个与机器内存相关的错误，例如错误:无法分配大小为 990.1 MB 的向量。解决办法是增加机器配置或与商品硬件并行。

监督机器学习算法

在这一部分，我们将学习监督机器学习算法。算法如下:

  • 线性回归
  • 逻辑回归

线性回归

线性回归主要是基于历史信息进行预测值的预测。回归是一种有监督的机器学习技术，用于识别目标变量和解释变量之间的线性关系。我们可以说它是用来预测目标变量值的数值形式。

在下一节中，我们将学习使用 R 的线性回归以及使用 R 和 Hadoop 的线性回归。

这里，将被预测的变量视为目标变量，将帮助预测目标变量的变量称为解释变量。通过线性关系，我们可以确定解释变量的变化对目标变量的影响。

在数学中，回归可以表述如下:

y = ax +e

其他公式包括:

  • The slope of the regression line is given by:

    a= （NSxy - （Sx）（Σy）） / （NSx 2 - （Sx） 2 ）

  • The intercept point of regression is given by:

    e = （Σy - b（Σx）） / N

这里， x 和 y 是构成数据集的变量， N 是数值的总数。

假设我们有下表所示的数据:

|

x

|

y

|
| --- | --- |
| Sixty-three | Three point one |
| Sixty-four | Three point six |
| Sixty-five | Three point eight |
| Sixty-six | four |

如果我们有一个新的值 x ，我们可以借助回归公式得到 y 的值。

线性回归的应用包括:

  • 销售预测
  • 预测最佳产品价格
  • 预测各种来源和活动的下一次在线购买

让我们看一下为所提供的数据集实现回归模型的统计技术。假设我们得到了 n 个统计数据单元。

Linear regression

其公式如下:

y = e0+a0x0+a1x1+a2x2+a3x3+a4x4

这里 Y 是目标变量(响应变量) xi 是解释变量e0T9】是平方误差项之和，可以认为是噪声。为了得到更准确的预测，我们需要借助call函数尽快将这个误差项减少为。

R 的线性回归

现在我们来看看如何在 r 中进行线性回归，我们可以使用内置的lm()方法来用 r 建立线性回归模型。

Model <-lm(target ~ ex_var1, data=train_dataset)

它将基于所提供的数据集的属性建立一个回归模型，并存储所有用于从模型变量值预测和识别数据模式的变量系数和模型参数。

# Defining data variables
X = matrix(rnorm(2000), ncol = 10)
y = as.matrix(rnorm(200))

# Bundling data variables into dataframe
train_data <- data.frame(X,y)

# Training model for generating prediction
lmodel<- lm(y~ train_data $X1 + train_data $X2 + train_data $X3 + train_data $X4 + train_data $X5 + train_data $X6 + train_data $X7 + train_data $X8 + train_data $X9 + train_data $X10,data= train_data)

summary(lmodel)

以下是可以用前面的summary命令显示的各种模型参数:

  • RSS :等于∑(yaactual-y)2。
  • 自由度 ( 自由度):用于识别预测模型的拟合程度，应尽可能小(逻辑上，值 0 表示完美预测)。
  • 残差标准误差 ( RSS/DF ):用于识别预测模型的拟合优度，应该尽可能小(逻辑上，值 0 表示完美预测)。
  • pr :这是一个变量被纳入模型的概率；要包含的变量应该小于 0.05。
  • t 值:这个等于 15。
  • f :这是检查 R 平方是否为非零值的统计量。

Linear regression with R

用 R 和 Hadoop 进行线性回归

假设我们有一个大数据集。我们现在将如何进行回归数据分析？在这种情况下，我们可以使用 R 和 Hadoop 集成来通过实现映射器和减速器来执行并行线性回归。它会将数据集分成可用节点中的块，然后它们会并行处理分布式数据。当我们使用 R 和 Hadoop 集群运行时，它不会引发内存问题，因为大数据集将在 Hadoop 计算节点之间使用 R 进行分发和处理。此外，请记住，这种实现的方法不能提供比 lm()模型更高的预测精度。

这里使用 RHadoop 进行 R 和 Hadoop 的集成，这是 Revolution Analytics 值得信赖的开源发行版。欲了解更多关于 RHadoop 的信息，请访问https://github.com/RevolutionAnalytics/RHadoop/wiki。在 RHadoop 的包中，这里我们只使用了rmr和rhdfs库。

让我们看看如何使用 R 和 Hadoop 数据技术执行回归分析。

# Defining the datasets with Big Data matrix X
X = matrix(rnorm(20000), ncol = 10)
X.index = to.dfs(cbind(1:nrow(X), X))
y = as.matrix(rnorm(2000))

这里Sum()功能是可重复使用的，如下代码所示:

# Function defined to be used as reducers 
Sum = 
  function(., YY) 
    keyval(1, list(Reduce('+', YY)))

线性回归算法的概要如下:

  1. 用 MapReduce 作业 1 计算Xtx值。
  2. 用 MapReduce 作业 2 计算Xty值。
  3. 用Solve (Xtx, Xty)导出系数值。

让我们逐一了解这些步骤。

第一步是用 MapReduce 作业 1 计算Xtx值。

  1. 大矩阵以整行的块传递给映射器。为这些子矩阵计算较小的叉积，并传递给单个 Reducer，Reducer 将它们相加。因为我们只有一个键，所以组合器是强制的，并且因为矩阵和是关联的和可交换的，所以我们当然可以在这里使用它。

    # XtX = 
  values(

# For loading hdfs data in to R 
    from.dfs(

# MapReduce Job to produce XT*X
      mapreduce(
        input = X.index,

# Mapper – To calculate and emitting XT*X
        map = 
          function(., Xi) {
            yi = y[Xi[,1],]
            Xi = Xi[,-1]
            keyval(1, list(t(Xi) %*% Xi))},

# Reducer – To reduce the Mapper output by performing sum operation over them
        reduce = Sum,
        combine = TRUE)))[[1]]

  2. 当 Hadoop 分布式文件系统 ( HDFS 中存储了大量数据时，我们需要将其路径值传递给MapReduce方法中的输入参数。

  3. 在前面的代码中，我们看到X是设计矩阵，它是用以下函数创建的:

    X = matrix(rnorm(2000), ncol = 10)

  4. Its output will look as shown in the following screenshot:

    Linear regression with R and Hadoop

因此，这里所有的列都将被视为解释变量，它们的标准误差可以用类似于我们用正态线性回归计算它们的方式来计算。

使用 MapReduce 作业 2 计算Xty值与计算向量y几乎相同，根据正常范围规则，向量对节点可用。

Xty = values(

# For loading hdfs data
from.dfs(

# MapReduce job to produce XT * y
      mapreduce(
       input = X.index,

# Mapper – To calculate and emitting XT*y
        map = function(., Xi) {
          yi = y[Xi[,1],]
          Xi = Xi[,-1]
          keyval(1, list(t(Xi) %*% yi))},

# Reducer – To reducer the Mapper output by performing # sum operation over them
        reduce = Sum,
        combine = TRUE)))[[1]]

要用solve (Xtx, Xty)导出系数值，请使用以下步骤:

  1. 最后，我们只需要调用下面一行代码就可以得到系数值。

    solve(XtX, Xty)

  2. The output of the preceding command will be as shown in the following screenshot:

    Linear regression with R and Hadoop

逻辑回归

在统计学中，逻辑回归或 logit 回归是一种概率分类模型。逻辑回归广泛应用于许多学科，包括医学和社会科学领域。它可以是二项式或多项式。

二元逻辑回归处理因变量的结果可能有两种可能类型的情况。多项式逻辑回归处理结果可能有三种或三种以上可能类型的情况。

逻辑回归可以使用这里列出的逻辑函数来实现。

  • To predict the log odds ratios, use the following formula:

    logit(p) = β0 + β1 × x1 + β2 × x2 +...+ βn × xn

  • The probability formula is as follows:

    p = elogit(p)1+elogit(p)

logit(p)是解释变量 X 的线性函数(x1，x2，x3..xn)，这类似于线性回归。因此，这个函数的输出将在 0 到 1 的范围内。根据概率得分，我们可以设置它的概率范围从 0 到 1。在大多数情况下，如果分数大于 0.5，将被视为 1，否则为 0。同样，我们可以说它提供了一个分类边界来对结果变量进行分类。

Logistic regression

上图中的是一个训练数据集。基于训练数据集图，我们可以说在 r 中有一个由glm模型生成的分类边界。

逻辑回归的应用包括:

  • 预测在线购买的可能性
  • 检测糖尿病的存在

R 的逻辑回归

为了用 R 执行逻辑回归，我们将使用iris数据集和glm模型。

#loading iris dataset
data(iris)

# Setting up target variable
target <- data.frame(isSetosa=(iris$Species == 'setosa'))

# Adding target to iris and creating new dataset
inputdata <- cbind(target,iris)

# Defining the logistic regression formula
formula <- isSetosa ~ Sepal.Length + Sepal.Width + Petal.Length + Petal.Width

# running Logistic model via glm()
logisticModel <- glm(formula, data=inputdata, family="binomial")

基于 R 和 Hadoop 的逻辑回归

为了用 R 和 Hadoop 执行逻辑回归，我们将使用带有rmr2的 RHadoop。

逻辑回归算法的概要如下:

  • 定义 lr.map映射器功能
  • 定义lr.reducer减速器功能
  • 定义logistic.regression地图缩减功能

让我们一个一个地理解它们。

我们将首先定义梯度下降的逻辑回归函数。多元回归可以通过将非相关变量形成矩阵数据格式来执行。对于阶乘变量，我们可以将它们转换为二进制变量来拟合模型。该功能将要求input、iterations、dims和alpha作为输入参数。

  • lr.map:这个代表逻辑回归映射器，它将计算子集点对梯度的贡献。

    # Mapper – computes the contribution of a subset of points to the gradient.

lr.map = 
    function(., M) {
      Y = M[,1] 
      X = M[,-1]
      keyval(
        1,
        Y * X * 
          g(-Y * as.numeric(X %*% t(plane))))}

  • lr.reducer:这个代表逻辑回归缩减器，它执行的只是关键 1 所有值的大和。

    # Reducer – Perform sum operation over Mapper output.

lr.reduce =
    function(k, Z) 
      keyval(k, t(as.matrix(apply(Z,2,sum))))

  • logistic.regression:主要定义logistic.regression MapReduce 功能，输入参数如下。调用这个函数将开始执行 MapReduce 函数的逻辑回归。

    • input:这是一个输入数据集
    • iterations:这是计算梯度的固定迭代次数
    • dims:这是输入变量的维度
    • alpha:这是学习率

让我们看看如何开发逻辑回归函数。

# MapReduce job – Defining MapReduce function for executing logistic regression

logistic.regression = 
  function(input, iterations, dims, alpha){
  plane = t(rep(0, dims))
  g = function(z) 1/(1 + exp(-z))
  for (i in 1:iterations) {
    gradient = 
      values(
        from.dfs(
          mapreduce(
            input,
            map = lr.map,
            reduce = lr.reduce,
            combine = T)))
    plane = plane + alpha * gradient }
  plane }

让我们如下运行逻辑回归函数:

# Loading dataset
data(foodstamp)

# Storing data to hdfs 
testdata <-  to.dfs(as.matrix(foodstamp))

# Running logistic regression with R and Hadoop
print(logistic.regression(testdata,10,3,0.05))

前面命令的输出如下:

Logistic regression with R and Hadoop

无监督机器学习算法

在机器学习中，无监督学习用于从未标记的数据集中寻找隐藏结构。由于数据集没有标记，因此在评估潜在解决方案时不会出现错误。

无监督机器学习包括几种算法，其中一些如下:

  • 使聚集
  • 人工神经网络
  • 矢量量化

我们将在这里考虑流行的聚类算法。

聚类

聚类是将一组对象分组的任务，其方式是将具有相似特征的相似对象分组在同一类别中，而将其他对象分组在其他类别中。在聚类中，输入数据集没有标记；它们需要根据数据结构的相似性进行标记。

在无监督的机器学习中，分类技术在所提供的一组输入训练数据集的帮助下执行相同的过程来将数据映射到一个类别。相应的过程称为聚类(或聚类分析)，包括根据某种固有的相似性度量将数据分组到类别中；例如，数据点之间的距离。

从下图中，我们可以将聚类识别为基于相似性对对象进行分组:

Clustering

R 库中有几种可用的聚类技术，如 k-means、k-medoids、层次聚类和基于密度的聚类。其中，k-means 被广泛用作数据科学中的聚类算法。该算法要求用户侧输入多个聚类作为输入参数。

聚类的应用如下:

  • 市场分割
  • 社交网络分析
  • 组织计算机网络
  • 天文数据分析

用 R 聚类

我们正在考虑在iris输入数据集上实现聚类模型的k-means方法，只需调用其内置的 R 数据集——即iris数据即可实现(更多信息，请访问。这里我们将看到如何用 r 进行 k-means 聚类。

# Loading iris flower dataset
data("iris")
# generating clusters for iris dataset
kmeans <- kmeans(iris[, -5], 3, iter.max = 1000)

# comparing iris Species with generated cluster points
Comp <- table(iris[, 5], kmeans$cluster)

为小数据集导出聚类非常简单，但是为大数据集导出需要使用 Hadoop 来提供计算能力。

用 R 和 Hadoop 进行聚类

既然 k-means 聚类算法已经在 RHadoop 中开发出来了，我们就要使用并理解它。您可以根据输入数据集的格式在其映射器和缩减器中进行更改。当我们处理 Hadoop 时，我们需要开发以并行方式在节点上运行的映射器和缩减器。

聚类算法的概要如下:

  • 定义 dist.fun距离函数
  • 定义 k-means.map k-means 映射函数
  • 定义 k-means.reduce k-means Reducer 功能
  • 定义 k-means.mr k-means MapReduce 函数
  • 定义要提供给聚类算法的输入数据点

现在我们将通过提供所需的参数来运行k-means.mr(k-means MapReduce 作业)。

让我们一个一个地理解它们。

  • dist.fun:首先我们来看dist.fun函数，计算一个中心的矩阵C和一个点的矩阵P之间的距离，已经测试过了。它可以在大约 16 秒内产生 10 个 6 点和 10 个 2 五维中心。

    # distance calculation function
dist.fun = 
      function(C, P) {
        apply(
          C,
          1, 
          function(x) 
            colSums((t(P) - x)^2))}

  • k-means.map:k-means MapReduce 算法的 Mapper 将计算点与所有中心之间的距离，并为每个点返回最近的中心。这个映射器将基于下面的代码在迭代中运行。在第一次迭代中，聚类中心将被随机分配，并且从下一次迭代开始，它将基于离聚类的所有点的最小距离来计算这些聚类中心。

    # k-Means Mapper
  kmeans.map = 
      function(., P) {
        nearest = {

# First interations- Assign random cluster centers 
          if(is.null(C)) 
            sample(
              1:num.clusters, 
              nrow(P), 
              replace = T)

# Rest of the iterations, where the clusters are assigned # based on the minimum distance from points
          else {
            D = dist.fun(C, P)
            nearest = max.col(-D)}}

       if(!(combine || in.memory.combine))
          keyval(nearest, P) 
        else 
          keyval(nearest, cbind(1, P))}

  • k-means.reduce:k-means MapReduce 算法的 Reduce 将计算矩阵点的列平均值作为关键。

    # k-Means Reducer
kmeans.reduce = {

# calculating the column average for both of the 
# conditions

      if (!(combine || in.memory.combine) ) 
        function(., P) 
          t(as.matrix(apply(P, 2, mean)))
      else 
        function(k, P) 
          keyval(
            k, 
            t(as.matrix(apply(P, 2, sum))))}

  • kmeans.mr:定义 k-means MapReduce 函数需要指定几个输入参数，如下:

    • P:此表示输入数据点

    • num.clusters:这是集群的总数

    • num.iter:这是数据集要处理的迭代总数

    • combine:这将决定组合器应该启用还是禁用(TRUE或FALSE )

      # k-Means MapReduce – for 
kmeans.mr = 
  function(
    P, 
    num.clusters, 
    num.iter, 
    combine, 
    in.memory.combine) {
    C = NULL
    for(i in 1:num.iter ) {
      C = 
        values(

# Loading hdfs dataset
          from.dfs(

# MapReduce job, with specification of input dataset,
# Mapper and Reducer
            mapreduce(
              P,
              map = kmeans.map,
              reduce = kmeans.reduce)))
      if(combine || in.memory.combine)
        C = C[, -1]/C[, 1]
      if(nrow(C) < num.clusters) {
        C = 
          rbind(
            C,
            matrix(
              rnorm(
                (num.clusters - 
                   nrow(C)) * nrow(C)), 
              ncol = nrow(C)) %*% C) }}
        C}

  • 定义要提供给聚类算法的输入数据点:

    # Input data points
P = do.call(
      rbind, 
      rep(

        list(

# Generating Matrix of
          matrix(
# Generate random normalized data with sd = 10
            rnorm(10, sd = 10), 
            ncol=2)), 
        20)) + 
    matrix(rnorm(200), ncol =2)

  • 通过向其提供所需参数来运行kmeans.mr(k-means MapReduce 作业)。

    # Running kmeans.mr Hadoop MapReduce algorithms with providing the required input parameters

kmeans.mr(
      to.dfs(P),
      num.clusters = 12, 
      num.iter = 5,
      combine = FALSE,
      in.memory.combine = FALSE)

  • The output of the preceding command is shown in the following screenshot:

    Performing clustering with R and Hadoop

推荐算法

推荐是一种机器学习技术，用于根据与用户先前的项目的关联来预测用户想要什么新项目。推荐广泛应用于电子商务应用领域。通过这种灵活的数据和行为驱动的算法，企业可以通过交叉销售或追加销售来帮助确保在正确的时间向正确的客户自动建议相关选择，从而提高转化率。

例如，当顾客在亚马逊上寻找三星 Galaxy S IV/S4 手机时，商店也会推荐类似这款手机的其他手机，在购买此商品的顾客也购买了窗口中展示。

有两种不同类型的建议:

  • User-based recommendations: In this type, users (customers) similar to current user (customer) are determined. Based on this user similarity, their interested/used items can be recommended to other users. Let's learn it through an example.

    Recommendation algorithms

    假设有两个用户分别叫温德尔和詹姆斯；两人有着相似的兴趣，因为他们都在使用 iPhone。温德尔曾经用过两个物品，iPad 和 iPhone，所以会推荐詹姆斯使用 iPad。这是基于用户的推荐。

  • Item-based recommendations: In this type, items similar to the items that are being currently used by a user are determined. Based on the item-similarity score, the similar items will be presented to the users for cross-selling and up-selling type of recommendations. Let's learn it through an example.

    Recommendation algorithms

例如，一个名为 Vaibhav 的用户喜欢并使用以下书籍:

  • Apache·马胡特食谱皮耶罗·贾科姆利帕克特出版
  • Hadoop MapReduce 食谱**Thilina Gunarathne和Srinath Perera**Packt Publishing
  • Hadoop 现实世界解决方案食谱、 Brian Femiano 、 Jon Lentz 和 Jonathan R. Owens 、 Packt Publishing
  • 假人的大数据、弗恩·哈尔珀博士、朱迪思·赫维茨、玛西娅·考夫曼和艾伦·纽金特、约翰·威利&儿子出版社

基于前面的信息，推荐系统将预测瓦伊巴夫想读哪些新书，如下所示:

  • 采用 R 和 Hadoop 的大数据分析Vignesh PrajapatiPackt Publishing

现在我们将看到如何用 R 和 Hadoop 生成推荐。但是在走向 R 和 Hadoop 的结合之前，让我们首先看看如何用 R 生成它。这将明确概念，以将您生成的推荐系统转换为 MapReduce 推荐算法。在使用 R 和 Hadoop 生成推荐的情况下，我们将使用 Revolution Analytics 的 RHadoop 发行版。

在 R 中生成推荐的步骤

为了给用户生成推荐，我们需要有一个特殊格式的数据集，可以被算法读取。这里，我们将使用协作过滤算法来生成推荐，而不是基于内容的算法。因此，我们需要用户对可用项目集的评分信息。所以small.csv数据集以user ID, item ID, item's ratings的格式给出。

# user ID, item ID, item's rating
1,         101,     5.0
1,         102,     3.0
1,         103,     2.5
2,         101,     2.0
2,         102,     2.5
2,         103,     5.0
2,         104,     2.0
3,         101,     2.0
3,         104,     4.0
3,         105,     4.5
3,         107,     5.0
4,         101,     5.0
4,         103,     3.0
4,         104,     4.5
4,         106,     4.0
5,         101,     4.0
5,         102,     3.0
5,         103,     2.0
5,         104,     4.0
5,         105,     3.5
5,         106,     4.0

前面的代码和数据集是从《行动中的马宏，罗宾·阿尼尔，艾伦·弗里德曼，泰德·邓宁，和肖恩·欧文，曼宁出版物中复制的，网站是http://www.fens.me/。

可以从矩阵分解技术中得出如下建议:

Co-occurrence matrix * scoring matrix = Recommended Results

要生成推荐人，我们将按照给定的步骤进行:

  1. 计算共现矩阵。
  2. 建立用户评分矩阵。
  3. 生成建议。

在下一节中，我们将看到执行上述步骤的技术细节。

  1. 在第一部分，计算共现矩阵，我们将能够识别数据集中给定的共现项目集。简单地说，我们可以称之为从给定的数据集中计算项目对。

    # Quote plyr package
library (plyr)

# Read dataset
train <-read.csv (file = "small.csv", header = FALSE)
names (train) <-c ("user", "item", "pref") 

# Calculated User Lists
usersUnique <-function () {
  users <-unique (train $ user)
  users [order (users)]
}

# Calculation Method Product List
itemsUnique <-function () {
  items <-unique (train $ item)
  items [order (items)]
}

# Derive unique User Lists
users <-usersUnique () 

# Product List
items <-itemsUnique () 

# Establish Product List Index
index <-function (x) which (items %in% x)
data<-ddply(train,.(user,item,pref),summarize,idx=index(item)) 

# Co-occurrence matrix
Co-occurrence <-function (data) {
  n <-length (items)
  co <-matrix (rep (0, n * n), nrow = n)
  for (u in users) {
    idx <-index (data $ item [which(data$user == u)])
    m <-merge (idx, idx)
    for (i in 1: nrow (m)) {
      co [m$x[i], m$y[i]] = co[m$x[i], m$y[i]]+1
    }
  }
  return (co)
}

# Generate co-occurrence matrix
co <-co-occurrence (data)

  2. 根据用户的评分信息建立用户评分矩阵，可以为用户生成用户项评分矩阵。

    # Recommendation algorithm
recommend <-function (udata = udata, co = coMatrix, num = 0) {
  n <- length(items)

  # All of pref
  pref <- rep (0, n)
  pref[udata$idx] <-udata$pref

  # User Rating Matrix
  userx <- matrix(pref, nrow = n)

  # Scoring matrix co-occurrence matrix *
  r <- co %*% userx

  # Recommended Sort
  r[udata$idx] <-0
  idx <-order(r, decreasing = TRUE)
  topn <-data.frame (user = rep(udata$user[1], length(idx)), item = items[idx], val = r[idx])

  # Recommended results take months before the num
  if (num> 0) {
    topn <-head (topn, num)
  }

  # Recommended results take months before the num
  if (num> 0) {
    topn <-head (topn, num)
  }

  # Back to results 
  return (topn)
}

  3. 最后，作为输出的推荐可以通过矩阵项:共现矩阵和用户评分矩阵的乘积运算生成。

    # initializing dataframe for recommendations storage
recommendation<-data.frame()

# Generating recommendations for all of the users
for(i in 1:length(users)){
  udata<-data[which(data$user==users[i]),]
  recommendation<-rbind(recommendation,recommend(udata,co,0)) 
}

类型

通过桃金娘和界面生成推荐非常容易。更多信息请参考https://github.com/jwijffels/Myrrix-R-interface。

用 R 和 Hadoop 生成推荐

为了用 R 和 Hadoop 生成推荐，我们需要开发一种算法，该算法将能够以并行方式运行和执行数据处理。这可以使用映射器和减少器来实现。这一部分非常有趣的部分是我们如何使用 R 和 Hadoop 一起从大数据集生成推荐。

因此，这里有一些类似于用 R 生成建议的步骤，但是将它们转换成 Mapper 和 Reducer 范例有点棘手:

  1. 建立共现矩阵项。
  2. 建立文章的用户评分矩阵。
  3. 生成建议。

我们将使用与之前对 R 的操作相同的概念，用 R 和 Hadoop 生成推荐。但是在这种情况下，我们需要使用键值范式，因为它是并行操作的基础。因此，每个功能都将通过考虑键值范式来实现。

  1. In the first section, establishment of the co-occurrence matrix items, we will establish co-occurrence items in steps: grouped by user, locate each user-selected items appearing alone counting, and counting in pairs.

    # Load rmr2 package
library (rmr2)

# Input Data File
train <-read.csv (file = "small.csv", header = FALSE)
names (train) <-c ("user", "item", "pref")

# Use the hadoop rmr format, hadoop is the default setting.
rmr.options (backend = 'hadoop')

# The data set into HDFS
train.hdfs = to.dfs (keyval (train$user, train))

# see the data from hdfs
from.dfs (train.hdfs)

    需要注意的要点是:

    • train.mr:这是 MapReduce 作业的键值范式信息
    • 键:这是物品矢量列表
    • 值:这是项目组合向量
    # MapReduce job 1 for co-occurrence matrix items
train.mr <-mapreduce (
  train.hdfs, 
  map = function (k, v) {
    keyval (k, v$item)
  }

# for identification of co-occurrence items
  , Reduce = function (k, v) {
    m <-merge (v, v)
    keyval (m$x, m$y)
  }
)

    将共现矩阵项进行合并计数。

    要定义一个 MapReduce 作业，step2.mr用于计算项目组合的频率。

    • Step2.mr:这是 MapReduce 作业的关键价值范式信息
    • 键:这是物品矢量列表
    • 值:这是同现矩阵数据框值(item、item、Freq)
    # MapReduce function for calculating the frequency of the combinations of the items.
step2.mr <-mapreduce (
  train.mr,

  map = function (k, v) {
    d <-data.frame (k, v)
    d2 <-ddply (d,. (k, v), count)

    key <- d2$k
    val <- d2
    keyval(key, val)
  }
)

# loading data from HDFS
from.dfs(step2.mr)

  2. To establish the user-scoring matrix to articles, let us define the Train2.mr MapReduce job.

    # MapReduce job for establish user scoring matrix to articles

train2.mr <-mapreduce (
  train.hdfs, 
  map = function(k, v) {
      df <- v

# key as item
    key <-df $ item

# value as [item, user pref]
    val <-data.frame (item = df$item, user = df$user, pref = df$pref)

# emitting (key, value)pairs
    keyval(key, val)
  }
)

# loading data from HDFS
from.dfs(train2.mr)
    • Train2.mr:这是 MapReduce 作业的关键价值范式信息
    • 键:这是物品清单
    • 值:这是用户商品评分矩阵的值

    以下是合并和同现评分矩阵:

    # Running equi joining two data – step2.mr and train2.mr
eq.hdfs <-equijoin (
  left.input = step2.mr, 
  right.input = train2.mr,
  map.left = function (k, v) {
    keyval (k, v)
  },
  map.right = function (k, v) {
    keyval (k, v)
  },
  outer = c ("left")
)

# loading data from HDFS
from.dfs (eq.hdfs)
    • eq.hdfs:这是 MapReduce 作业的关键价值范式信息
    • 键:这里的键为空
    • 值:这是合并后的数据帧值

  3. In the section of generating recommendations, we will obtain the recommended list of results.

    # MapReduce job to obtain recommended list of result from equijoined data
cal.mr <-mapreduce (
  input = eq.hdfs,

  map = function (k, v) {
    val <-v
    na <-is.na (v$user.r)
    if (length (which(na))> 0) val <-v [-which (is.na (v $ user.r)),]
    keyval (val$kl, val)
  }
  , Reduce = function (k, v) {
    val <-ddply (v,. (kl, vl, user.r), summarize, v = freq.l * pref.r)
    keyval (val $ kl, val)
  }
)

# loading data from HDFS
from.dfs (cal.mr)
    • Cal.mr:这是 MapReduce 作业的关键价值范式信息
    • 键:这是物品清单
    • 值:这是推荐的结果数据框值

    通过定义获得具有偏好值的推荐项目列表的结果，排序过程将应用于推荐结果。

    # MapReduce job for sorting the recommendation output
result.mr <-mapreduce (
  input = cal.mr,
  map = function (k, v) {
    keyval (v $ user.r, v)
  }
  , Reduce = function (k, v) {
    val <-ddply (v,. (user.r, vl), summarize, v = sum (v))
    val2 <-val [order (val$v, decreasing = TRUE),]
    names (val2) <-c ("user", "item", "pref")
    keyval (val2$user, val2)
  }
)
# loading data from HDFS
from.dfs (result.mr)
    • result.mr:这是 MapReduce 作业的关键价值范式信息
    • 键:这是用户 ID
    • 值:这是推荐的结果数据框值

在这里，我们设计了生成基于项目推荐的协同算法。自从我们试图让它在并行节点上运行以来，我们一直关注映射器和缩减器。在某些情况下，它们可能不是最佳的，但是您可以通过使用可用的代码来使它们成为最佳的。

总结

在这一章中，我们学习了如何在 R 和 Hadoop 技术的帮助下，通过机器学习来执行大数据分析。在下一章中，我们将学习如何通过将 R 集成到各种外部数据源来丰富 R 中的数据集。

七、从各种数据库导入和导出数据

在最后一章中，我们将看到如何将来自不同来源的数据加载到 R 中，以执行数据分析操作。在这里，我们考虑了一些被用作数据存储的流行数据库，这些数据库是使用不同的应用和技术执行数据分析所必需的。正如我们所知，与其他分析工具相比，用 R 执行分析操作相当容易，而且它是免费的和开源的。由于 R 有通过安装 R 包来使用定制功能的可用方法，所以在 CRAN 中有许多数据库包可以与 R 进行数据库连接。因此，由于数据库以及操作系统的独立性，R 编程语言变得越来越流行。

我们专门设计了这一章来分享如何将来自各种数据库系统的数据加载到 R 中并用于执行数据建模的知识。在这一章中，我们包含了几个用于执行各种数据库操作的流行数据库示例。

我们已经介绍了各种流行的和 r 一起使用的数据源。它们如下:

  • -达达
  • 关系型数据库
  • 擅长
  • MongoDB
  • SQLite
  • 一种数据库系统
  • 储备
  • 巴什

Importing and Exporting Data from Various DBs

从上图中，我们可以了解到，多个数据库系统支持 R 在各种数据库上执行数据分析相关操作。由于有大量的库可供 R 执行与各种数据库的连接，我们只需要继承它们。

下表给出了可能的数据库系统和相关的 R 包，以便于理解相关的 R 包:

|

数据库系统名称

|

有用的 R 包/函数实用程序

|
| --- | --- |
| 文本文件 | 文本数据文件，如.csv、.txt、.r |
| 关系型数据库 | RMySQL |
| 擅长 | Xlsx |
| 蒙戈 | RMongo |
| SQLlite | sqlite |
| 一种数据库系统 | 一种数据库系统 |
| HDFS | RHDFS |
| 储备 | RHive |
| 巴什 | hbase |

正如我们所知，每个提到的数据库都有它们自己的重要特性。为了更好地理解，这些数据源中的每一个都将通过以下几点进行描述:

  • 介绍
  • 特征
  • 装置
  • 将数据导入 R
  • 数据操作
  • 从 R 导出数据

在本章中，我们将安装 R 包并与之交互，这些包将用于 R 中的各种数据操作。

现在，我们将开始了解数据库，以及如何执行与数据相关的操作，以便对所有数据库进行数据分析。

了解数据文件作为数据库

在处理数据分析活动时，我们需要一直进行数据导入、加载或导出功能。有时候同样的操作需要用 R 编程语言迭代。因此，我们可以使用可用的 R 函数来执行相同的数据活动。

了解不同类型的文件

通常有四种不同类型的数据文件与 R 一起用于数据存储操作。它们如下:

  • 逗号分隔值
  • Txt (制表符分隔值)
  • 。RDATA (R 的原生数据格式)
  • 。rda (R 的原生数据格式)

安装 R 包

要使用前面指定格式的数据文件，我们不需要安装额外的 R 包。我们只需要使用 r 提供的内置功能

将数据导入 R

要执行分析相关的活动，我们需要使用以下函数将数据输入 R:

  • CSV: read.csv()用于读取逗号分隔值 ( CSV )文件，其中小数点为",". ，检索到的数据将存储到一个 R 对象中，该对象被认为是Dataframe。

    Dataframe <- read.csv("data.csv",sep=",")

  • TXT:检索制表符分隔值时，read.table()函数将与一些重要参数一起使用，该函数的返回类型为Dataframe type。

    Dataframe <- read.table("data.csv", sep="\t")

  • 。给你，这个。R 使用 RDATA 格式存储特定时间段的工作空间数据。它被认为是图像文件。这将存储/检索工作区中所有可用的数据。

    load("history.RDATA")

  • 。rda:这也是 R 的原生数据格式，按照需求存储具体的数据变量。

    load("data_variables_a_and_b.rda")

从 R 导出数据

要从 R 导出现有数据对象，并按照要求支持数据文件为，我们需要使用以下功能:

  • CSV:通过以下命令将数据框对象写入csv数据文件:

    write.csv(mydata, "c:/mydata.csv", sep=",", row.names=FALSE)

  • TXT:通过以下命令用制表符分隔符写入数据:

    write.table(mydata, "c:/mydata.txt", sep="\t")

  • 。RDATA:要存储 R 会话可用的工作空间数据变量，请使用以下命令:

    save.image()

  • 。rda:这个函数用于存储以后可以重用的特定数据对象。使用以下代码将它们保存到。rda文件。

    # column vector
a <- c(1,2,3)

# column vector
b <- c(2,4,6)

# saving it to R (.rda) data format
save(a, b, file=" data_variables_a_and_b.rda")

了解 MySQL

MySQL 是世界上最受欢迎的开源数据库。包括脸书、谷歌、Adobe 和 Zappos 在内的许多全球最大、发展最快的组织都依赖 MySQL 数据库来节省时间和资金，为大容量网站、关键业务系统和软件包提供动力。

因为 R 和 MySQL 都是开源的，所以它们可以用于构建交互式网络分析应用。此外，利用这个独特的包，可以为现有的 web 应用执行简单的数据分析活动。

要在您的 Linux 机器上安装 MySQL，您需要按顺序遵循给定的步骤:

  • 安装 MySQL
  • 安装 RMySQL

安装 MySQL

我们将看看如何在 Linux 上安装 MySQL:

// Updating the linux package list
sudo apt-get update

// Upgrading the updated packages
sudo apt-get dist-upgrade

//First, install the MySQL server and client packages:
sudo apt-get install mysql-server mysql-client

类型

使用以下命令登录到 MySQL 数据库:

mysql -u root -p

安装 RMySQL

现在，我们已经在我们的 Linux 机器上安装了 MySQL。现在是通过以下命令从 CRAN 安装 RMySQL–R 库的时候了:

# to install RMySQL library
install.packages("RMySQL")

#Loading RMySQL
library(RMySQL)

将 RMySQL 库安装到 R 上后，通过提供 MySQL 管理控制台中提供的用户权限来执行 MySQL 数据库连接:

mydb = dbConnect(MySQL(), user='root', password='', dbname='sample_table', host='localhost')

学习列出表格及其结构

现在，数据库连接已经成功完成。要列出 MySQL 数据库中可用的数据库表及其结构，请看下面的命令。要返回在mydb数据库下创建的可用表，请使用以下命令:

dbListTables(mydb)

要返回在sample_table表下创建的数据字段列表，请使用以下命令:

dbListFields(mydb, 'sample_table')

将数据导入 R

我们知道如何检查 MySQL 表及其字段。在识别出有用的数据表之后，我们可以使用下面的 RMySQL 命令将它们导入到 R 中。为了根据提供的 SQL 查询从 MySQL 数据库中检索定制数据，我们需要将它存储在一个对象中:

rs = dbSendQuery(mydb, "select * from sample_table")

可用的数据相关信息可以通过fetch命令从 MySQL 检索到 R，如下所示:

dataset = fetch(rs, n=-1)

这里，指定参数n = -1用于检索所有待定记录。

理解数据操作

要对 MySQL 数据库执行数据操作，我们需要启动 SQL 查询。但是在 RMySQL 的情况下，我们可以用dbSendQuery函数发出命令。

使用以下命令可以在 MySQL 数据库中的可用数据框的帮助下创建一个新表:

dbWriteTable(mydb, name='mysql_table_name', value=data.frame.name)

要在 MySQL 中的现有数据表中插入 R 矩阵数据，请使用以下命令:

# defining data matrix
datamatrix <- matrix(1:4, 2, 2)

# defining query to insert the data
query <- paste("INSERT INTO names VALUES(",datamatrix [1,1], ",", datamatrix [1,2], ")")

# command for submitting the defined SQL query dbGetQuery(con, query)

有时，当 MySQL 表不再使用时，我们需要删除它。我们可以通过以下查询来删除mysql_some_table表:

dbSendQuery(mydb, 'drop table if exists mysql_some_table').

理解 Excel

Excel 是微软开发的在 Windows 和 Mac OS 上运行的电子表格应用，具有与 R 类似的功能，用于执行统计计算、图形可视化和数据建模。Excel 是微软提供的微软 Office 捆绑包，主要支持.xls电子表格数据文件格式。在这种情况下，我们想从 R 内部读取或写入微软 Excel 电子表格，我们可以使用许多可用的 R 包。但是其中一个流行且有效的 R 库是 xlsx。

这个包通过编程的方式提供了对 Excel 文件的控制。这个的高级应用编程接口允许用户将.xlsx文档的扩展表读入data.frame并将data.frame写入文件。这个包基本上是由阿德里安·德拉古列斯库开发的。

安装 Excel

这里我们是考虑.xls文件作为数据源，可以借助微软 Excel 97/2000/XP/2003 进行的搭建和维护。

以下是 xlsx 包的先决条件:

  • xlsxjars
  • 棕色

安装 xlsxX 包:

  • Install.packages("xlsxjars ")
  • install . packages(“rJava”)
  • Install.packages("xlsx ")

将数据导入 R

假设我们已经创建了一个 excel 文件，现在我们想用 R 执行数据分析相关操作，这是加载要在 R 内处理的 excel 文件的最佳包。

es <- read.xlsx("D:/ga.xlsx",1)

前面的命令将表格 1 中的 excel 数据存储为 r 中的es数据框格式

用 R 和 Excel 理解数据操作

以下命令将用于选择数据帧的子集res，该子集选择前五行:

r <- res[1:5,]

将数据导出到 Excel

根据定义的名称，处理后的数据帧格式的数据可以存储为xls文件，由 Excel 支持。

ress <- write.xlsx(r, "D:/ga1.xls")

了解 MongoDB

MongoDB 是一个基于 NoSQL 的分布式文档数据存储。这是专为提供可扩展的高性能数据存储解决方案而设计的。在许多情况下，它可以用来取代传统的关系数据库或键/值数据存储。Mongo 最大的特点就是它的查询语言，非常强大，语法也有点类似于面向对象的查询语言。

以下是 MongoDB 的特性:

  • 面向集合的存储和易于存储的对象类型
  • 支持动态查询
  • 完全索引支持
  • 丰富的查询语言
  • 数据片段处理，以支持云级别的扩展
  • 基于 BSON 的文件数据存储
  • 支持 C、C++、C#、Erlang、Haskell、Java、JavaScript、Perl、PHP、Python、Ruby 和 Scala

通过安装以下先决条件，我们可以一起使用 R 和 MongoDB:

  • mongodb 安装
  • rmongodb 安装

安装 MongoDB

以下是在 Ubuntu 12.04 和 CentOS 中安装 MongoDB 的步骤:

首先我们会看到 Ubuntu 的安装步骤。

  1. 使用以下命令配置包管理系统(APT):

    sudo apt-key adv --keyserverhkp://keyserver.ubuntu.com:80 --recv 7F0CEB10

  2. 使用以下命令创建/etc/apt/sources.list.d/mongodb.list:

    echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | sudo tee /etc/apt/sources.list.d/mongodb.list

  3. 现在，使用以下命令更新操作系统的软件包列表:

    sudo apt-get update

  4. 使用以下命令安装最新版本的 MongoDB:

    apt-get install mongodb-10gen

现在，我们将看到 CentOs 的安装步骤。

  1. 配置包管理系统。

  2. 创建/etc/yum.repos.d/mongodb.repo并使用以下配置:

    • 对于 64 位系统，使用以下命令:

      [mongodb]
name=MongoDB Repository
baseurl=http://downloads-distro.mongodb.org/repo/redhat/os/x86_64/
gpgcheck=0
enabled=1

    • 对于 32 位系统，使用以下命令:

      [mongodb]
name=MongoDB Repository
baseurl=http://downloads-distro.mongodb.org/repo/redhat/os/i686/
gpgcheck=0
enabled=1

  3. 安装软件包。

使用以下命令，安装 MongoDB 的稳定版本和相关工具:

yum install mongo-10gen mongo-10gen-server

现在，您已经成功安装了 MongoDB。

类型

用于控制 mongodb 服务的有用命令

要启动 mongodb 服务，我们使用以下命令:

sudo service mongodb start

要停止 mongodb 服务，我们使用以下命令:

sudo service mongodb stop

要重新启动 mongodb 服务，我们使用以下命令:

sudo service mongodb restart

要启动一个 Mongo 控制台，我们使用以下命令:

mongo

将 SQL 映射到 MongoDB

以下是 SQL 术语到 MongoDB 术语的映射，以便更好地理解数据存储:

|

号码

|

SQL 术语

|

蒙古数据库术语

|
| --- | --- | --- |
| 1. | 数据库ˌ资料库 | 数据库ˌ资料库 |
| 2. | 桌子 | 收藏品 |
| 3. | 索引 | 索引 |
| 4. | 排 | 文件 |
| 5. | 圆柱 | 田 |
| 6. | 连接 | 嵌入和链接 |

将 SQL 映射到 MongoQL

以下是为了理解查询开发/转换，SQL 语句到 Mongo QL 语句的映射:

|

号码

|

SQL 语句

|

蒙戈·QL 声明

|
| --- | --- | --- |
| 1. |

INSERT INTO students VALUES(1,1)

|

$db->students->insert(array("a" => 1, "b" => 1));

|
| 2. |

SELECT a, b FROM students

|

$db->students->find(array(), array("a" => 1, "b" => 1));

|
| 3. |

SELECT * FROM students WHERE age < 15

|

$db->students->find(array("age" => array('$lt' => 15)));

|
| 4. |

UPDATE students SET a=1 WHERE b='q'

|

$db->students->update(array("b" => "q"), array('$set' => array("a" => 1)));

|
| 5. |

DELETE FROM students WHERE name="siddharth"

|

$db->students->remove(array("name" => " siddharth"));

|

安装 rmongodb

要在 R 内使用 MongoDB，我们需要在 rmongodb 库中安装 R。我们可以通过以下命令从 CRAN】安装 rmongodb:

# installing library rmongodb in R
install.packages (rmongodb)

将数据导入 R

我们已经学习了如何在 Ubuntu 12.04 中安装 MongoDB。现在，我们可以对数据执行所有必要的操作。在本节中，我们将学习如何在 R 中处理和导入 Mongo 数据，以进行数据分析活动。为了加载库，我们使用以下命令:

# loading the library of rmongodb
library (rmongodb)

Mongo connection establishment
mongo <-mongo.create ()

Check whether the normal series
mongo.is.connected (mongo)

Create a BSON object cache
buf <- mongo.bson.buffer.create ()

Add element to the object buf
mongo.bson.buffer.append (buf, "name", "Echo")

mongo.bson类的对象用于存储 BSON 文档。BSON 是 MongoDB 用来在其数据库中存储文档的形式。MongoDB 网络流量也使用 BSON 消息:

b <- mongo.bson.from.list(list(name="Fred", age=29, city="Boston"))iter <- mongo.bson.iterator.create(b)  # b is of class "mongo.bson"while (mongo.bson.iterator.next(iter))print(mongo.bson.iterator.value(iter))

理解数据操作

我们现在将看到 Mongo 数据对象如何在 R:

# To check whether mongo is connected or not in R.
if (mongo.is.connected(mongo)) {ns <- "test.people"
#Returns a fresh mongo.bson.buffer object ready to have data 
#appended onto it in R.buf <- mongo.bson.buffer.create()mongo.bson.buffer.append(buf, "name", "Joe")criteria <- mongo.bson.from.buffer(buf)

# mongo.bson.buffer objects are used to build mongo.bson objects.buf <- mongo.bson.buffer.create()
 mongo.bson.buffer.start.object(buf, "inc")mongo.bson.buffer.append(buf, "age", 1L)mongo.bson.buffer.finish.object(buf)objNew <- mongo.bson.from.buffer(buf)# increment the age field of the first record   matching name "Joe"mongo.update(mongo, ns, criteria, objNew)

# mongo.bson.buffer objects are used to build mongo.bson objects.buf <- mongo.bson.buffer.create()mongo.bson.buffer.append(buf, "name", "Jeff")criteria <- mongo.bson.from.buffer(buf)

# mongo.bson.buffer objects are used to build mongo.bson objects.buf <- mongo.bson.buffer.create()mongo.bson.buffer.append(buf, "name", "Jeff")mongo.bson.buffer.append(buf, "age", 27L)objNew <- mongo.bson.from.buffer(buf)# update the entire record to { name: "Jeff", age: 27 }# where name equals "Jeff"# if such a record exists; otherwise, insert this as a new reordmongo.update(mongo, ns, criteria, objNew,mongo.update.upsert)# do a shorthand update:mongo.update(mongo, ns, list(name="John"), list(name="John", age=25))}

了解 SQLite

SQLite 是用 C 编程语言开发的关系数据库管理系统。SQLite 符合 ACID 标准，并实现了大部分 SQL 标准。与其他数据库系统不同，SQLite 没有独立的进程向客户端应用提供数据。它是一个嵌入式的 SQL 数据库引擎。SQLite 系统直接读写系统磁盘文件，因为它是一个基于文件的数据库。包含多个表、索引和视图的相关 SQL 数据库，并且这种数据库文件格式支持跨平台。

快速理解事务的 ACID 属性:

需要满足一组属性来执行交易。它们是原子性、一致性、隔离性和 T2 持久性。其解释如下:

  • 原子性指的是保证执行数据库的所有任务。
  • 一致性确保数据库始终保持一致，类似于我们开始之前的情况。
  • 隔离是指在事务期间，其他操作不能访问或看到处于中间状态的数据的要求。
  • 持久性是指保证一旦用户被通知成功，事务将持续存在，并且不会被撤销。这意味着它将在系统故障中幸存下来，并且数据库系统已经检查了完整性约束，不需要中止事务。

了解 SQLite 的特性

以下是遵循 ACID 属性的 SQLite 数据库的特性:

  • 零配置
  • 跨平台支持的磁盘格式
  • 比客户机-服务器类型的数据库系统更快
  • 易于使用的应用编程接口

我们将要求同时使用 SQLite 和 R 的以下先决条件:

  • SQLite 安装
  • RSQLite 安装

安装 SQLite

要在 Ubuntu 中安装 SQlite 数据库，请遵循给定的命令:

// install sqllite by firing the following commands
sudo apt-get purge sqlite3 sqlite3-doc libsqlite3-0
sudo apt-get autoremove
sudo apt-get install sqlite3 sqlite3-doc

安装 RSQLite

我们可以按照给定的命令安装 RSQLite:

# installing RSQLite library from CRAN in R
Install.packages("RSQLite")

将数据导入 R

我们将看到如何用 RSQLite 包将数据插入 R。

要加载已安装的包，我们使用以下命令:

#loading the installed package
library("RSQLite")

使用以下命令，您可以连接到数据库并列出数据库中的所有表:

# connect to db
con <- dbConnect(SQLite(), dbname="data/first.db")

# list all tables
tables <- dbListTables(con)

# exclude sqlite_sequence (contains table information)
tables <- tables[tables != "sqlite_sequence"]
lDataFrames <- vector("list", length=length(tables))

# create a data.frame for each table
for (i in seq(along=tables)) {
 lDataFrames[[i]] <- dbGetQuery(conn=con, statement=paste("SELECT * FROM '", tables[[i]], "'", sep=""))
}

理解数据操作

我们可以使用以下命令操作数据集:

dbBeginTransaction(con)
rs <- dbSendQuery(con, "DELETE from candidates WHERE age > 50")
Exporting the data from Rdata(USArrests)
dbWriteTable(con, "USArrests", USArrests)

理解 PostgreSQL

PostgreSQL 是一个开源的对象关系数据库管理系统。PostgreSQL 运行在大多数操作系统上，如 Linux、UNIX 和 Windows。它支持文本、图像、声音和视频数据源。它支持 C、C++、Java、Python、Ruby 和 Tcl 等编程技术。

理解 PostgreSQL 的特性

以下是 PostgreSQL 的特性:

  • 复杂的 SQL 查询
  • 完全酸性投诉
  • SQL 子选择

我们需要为在 R 中使用 PostgreSQL 安装以下先决条件:

  • 安装 Postgre SQL
  • 安装 postgre sql

安装 PostgreSQL

在这一节，我们将学习如何安装 PostgreSQL。

安装 PostgreSQL 时将遵循给定的命令:

// updating the packages list
Sudo apt-get update

// installing postgresql 
sudo apt-get install postgresql postgresql-contrib

// creating postgresql user
su – postgres createuser

安装 RPostgreSQL

我们将现在看看如何安装和使用 RPostgreSQL:

# installing package from CRAN
install.packages(RPostgreSQL)
Importing the data into R# loading the installed package
library(RPostgreSQL)

## load the PostgreSQL driver
drv <- dbDriver("PostgreSQL")

## Open a connection
con <- dbConnect(drv, dbname="oxford")

## Submits a statement
rs <- dbSendQuery(con, "select * from student")

## fetch all elements from the result set
fetch(rs,n=-1)

## Closes the connection
dbDisconnect(con)

## Frees all the resources on the driver
dbUnloadDriver(drv)

随着跟随代码，我们将学习如何从 R:

opendbGetQuery(con, "BEGIN TRANSACTION")
rs <- dbSendQuery(con,
"Delete * from sales as p where p.cost>10")
if(dbGetInfo(rs, what = "rowsAffected") > 250){
  warning("Rolling back transaction")
  dbRollback(con)
}else{
  dbCommit(con)
}

从 R 导出数据

在部分，我们将学习如何加载数据，将 dataframe 值的内容写入指定的表名，并从数据库连接中删除指定的表:

conn <- dbConnect("PostgreSQL", dbname = "wireless")
if(dbExistsTable(con, "frame_fuel")){
  dbRemoveTable(conn, "frame_fuel")
  dbWriteTable(conn, "frame_fuel", fuel.frame)
}
if(dbExistsTable(conn, "RESULTS")){
  dbWriteTable(conn, "RESULTS", results2000, append = T)
  else
  dbWriteTable(conn, "RESULTS", results2000)
}

了解 Hive

Hive 是脸书开发的一个基于 Hadoop 的类似数据仓库的框架。它允许用户使用像 HiveQL 这样的语言在 SQL 中激发查询，这些语言高度抽象为 Hadoop MapReduce。这允许没有 MapReduce 经验的 SQL 程序员使用仓库，并使其更容易与业务智能和可视化工具集成，以进行实时查询处理。

了解 Hive 的特征

以下是 Hive 的特点:

  • 休眠查询语言(HQL)
  • UDF 支撑
  • 元数据存储
  • 数据索引
  • 不同的存储类型
  • Hadoop 集成

RHive 的先决条件如下:

  • Hadoop
  • 储备

我们在这里假设我们的读者已经配置了 Hadoop 否则他们可以从第 1 章、准备使用 R 和 Hadoop 中学习 Hadoop 安装。由于运行 RHive 需要 Hive，我们将首先看看如何安装 Hive。

安装蜂箱

安装 Hive 的命令如下:

// Downloading the hive source from apache mirror
wget http://www.motorlogy.com/apache/hive/hive-0.11.0/hive-0.11.0.tar.gz

// For extracting the hive source
tar xzvf  hive-0.11.0.tar.gz

设置配置单元配置

要设置配置单元配置，我们需要更新hive-site.xml文件，增加一些内容:

  • 使用以下命令更新hive-site.xml:

    <description> JDBC connect string for a JDBC metastore </ description>
</Property>

<property>
<name> javax.jdo.option.ConnectionDriverName </ name>
<value> com.mysql.jdbc.Driver </ value>
<description> Driver class name for a JDBC metastore </ description>
</Property>

<property>
<name> javax.jdo.option.ConnectionUserName </ name>
<value> hive </value>
<description> username to use against metastore database </ description>
</ Property>

<property>
<name> javax.jdo.option.ConnectionPassword </name>
<value> hive</value>
<description> password to use against metastore database </ description>
</Property>

<property>
<name> hive.metastore.warehouse.dir </ name>
<value> /user/hive/warehouse </value>
<description> location of default database for the warehouse </ description>
</Property>

  • 通过添加以下行更新【T0:

    log4j.appender.EventCounter = org.apache.hadoop.log.metrics.EventCounter

  • 使用以下命令更新环境变量:

    export $HIVE_HOME=/usr/local/ hive-0.11.0

  • In HDFS, create specific directories for Hive:

    $HADOOP_HOME/bin/ hadoop fs-mkidr /tmp
$HADOOP_HOME/bin/ hadoop fs-mkidr /user/hive/warehouse
$HADOOP_HOME/bin/ hadoop fs-chmod g+w / tmp
$HADOOP_HOME/bin/ hadoop fs-chmod g+w /user/hive/warehouse

    类型

    要启动 Hive 服务器，需要从HIVE_HOME调用hive --service hiveserver命令。

安装 RHive

  • 使用以下命令安装依赖的库:rjava

了解 RHive 操作

我们将看到如何使用 r Hive 库在 R 中加载和操作 Hive 数据集:

  • 要初始化 RHive，我们使用:

    rhive.init ()

  • 要连接到 Hive 服务器，我们使用:

    rhive.connect ("192.168.1.210")

  • 要查看所有表格，我们使用:

    rhive.list.tables ()
 tab_name
1 hive_algo_t_account
2 o_account
3 r_t_account

  • 要查看表格结构，我们使用:

    rhive.desc.table ('o_account');
 col_name data_type comment

1 id int
2 email string
3 create_date string

  • 执行我们使用的 HQL 查询:

    rhive.query ("select * from o_account");

  • 要关闭与 Hive 服务器的连接，我们使用:

    rhive.close()

了解糖化血红蛋白

Apache HBase 是一个面向 Hadoop 的分布式大数据存储。这允许随机、实时、读/写访问大数据。这是一个面向列的数据存储模型，在受到谷歌大表的启发后进行了创新。

了解糖化血红蛋白的特性

以下是糖化血红蛋白的特性:

  • 带有可扩展标记语言的 RESTful 网络服务
  • 线性和模块化可扩展性
  • 严格一致的读写
  • 可扩展外壳
  • 实时查询的块缓存和布隆过滤器

RHBase 的先决条件如下:

  • Hadoop
  • 巴什
  • 节约

这里我们假设用户已经为他们的 Linux 机器配置了 Hadoop。如果有人想知道如何在 Linux 上安装 Hadoop，请参考第 1 章、准备使用 R 和 Hadoop 。

安装糖化血红蛋白酶

之后是安装 HBase 的步骤:

  1. 下载 Hbase 的 tar 文件并提取:

    wget http://apache.cs.utah.edu/hbase/stable/hbase-0.94.11.tar.gz

tar -xzf hbase-0.94.11.tar.gz

  2. 转到 HBase 安装目录，更新配置文件:

    cd hbase-0.94.11/

vi conf/hbase-site.xml

  3. 修改配置文件:

    1. 更新hbase-env.sh。

      ~ Vi conf / hbase-env.sh

    2. 设置糖化血红蛋白的配置:

       export JAVA_HOME = /usr/lib/jvm/java-6-sun
 export HBASE_HOME = /usr/local/hbase-0.94.11
 export HADOOP_INSTALL = /usr/local/hadoop
 export HBASE_CLASSPATH = /usr/local/hadoop/conf
 export HBASE_MANAGES_ZK = true

    3. 更新hbase-site.xmlzxml :

      Vi conf / hbase-site.xml

    4. Change hbase-site.cml, which should look like the following code:

          <configuration>
      <property>
        <name> hbase.rootdir </name>
        <value> hdfs://master:9000/hbase </value>
      </Property>

      <property>
        <name>hbase.cluster.distributed </name>
        <value>true</value>
      </Property>

      <property>
         <name>dfs.replication </name>
         <value>1</value>
      </Property>

      <property>
        <name>hbase.zookeeper.quorum </name>
        <value>master</value>
      </Property>

      <property>
          <name>hbase.zookeeper.property.clientPort </name>
          <value>2181</value>
      </Property>

      <property>
        <name>hbase.zookeeper.property.dataDir </name>
        <value>/root/hadoop/hdata</​​value>
      </Property>
    </ Configuration>

      类型

      如果使用单独的电动开闭机设置，则需要更改配置。

    5. 复制 Hadoop 环境配置文件和库。

      Cp $HADOOP_HOME/conf/hdfs-site.xml $HBASE_HOME/conf
Cp $HADOOP_HOME/hadoop-core-1.0.3.jar $HBASE_HOME/lib
Cp $HADOOP_HOME/lib/commons-configuration-1.6.jar $HBASE_HOME/lib
Cp $HADOOP_HOME/lib/commons-collections-3.2.1.jar $HBASE_HOME/lib

安装节俭

以下是安装节电器的步骤:

  1. 从网上下载节俭源，放到客户端。我们将用 Ubuntu O.S 12.04:

    get http://archive.apache.org/dist/thrift/0.8.0/thrift-0.8.0.tar.gz

    来做

  2. 要提取下载的.tar.gz文件，请使用以下命令:

    tar xzvf thrift-0.8.0.tar.gz
cd thrift-0.8.0/

  3. 编译配置参数:

    ./Configure

  4. Install thrift:

    Make
Make install

    类型

    要启动 HBase 节俭服务器我们需要调用以下命令:

    $HBASE_HOME/bin/hbase-daemon.sh start

安装 RHBase

安装 HBase 后，我们将看到如何获取 RHBase 库。

  • 要安装rhbase，我们使用以下命令:

    wget https://github.com/RevolutionAnalytics/rhbase/blob/master/build/rhbase_1.2.0.tar.gz

  • 要安装下载的软件包，我们使用以下命令:

    R CMD INSTALL rhbase_1.2.0.tar.gz

将数据导入 R

一旦安装了 RHBase ，我们就可以借助 RHBase 从 HBase 加载 R 中的数据集:

  • 要列出我们使用的所有表格:

    hb.list.tables ()

  • 要创建新表，我们使用:

    hb.new.table ("student")

  • 要显示表格结构，我们使用:

    hb.describe.table("student_rhbase")

  • 要读取数据，我们使用:

    hb.get ('student_rhbase', 'mary')

理解数据操作

现在，我们将看看如何从 R:

  • 要创建表格，我们使用:

    hb.new.table ("student_rhbase", "info")

  • 插入我们使用的数据:

    hb.insert ("student_rhbase", list (list ("mary", "info: age", "24")))

  • 要删除我们使用的工作表:

    hb.delete.table ('student_rhbase')

总结

在本章中，我们学习了如何在 R 中加载与各种数据库系统及其数据集集成的各种 R 包来执行数据分析。大多数流行的数据库系统都有它们的 R 包来加载数据、更新以及查询数据来分析它们。

八、附录 a：参考文献

在本附录中，提供了与所有章节内容相关的附加资源。

R + Hadoop 帮助资料

R 组

Hadoop 组

R + Hadoop 组

热门 R 贡献者

  • RStudio(工作室)
    • 名称:RStudio
    • URL:http://www . rstudio . com/
    • 类型:R 社区的软件、教育和服务
    • 贡献:Rstudio IDE、plyr、Shiny、RPubs 和 devtools
  • 博客作者
  • 决策统计
  • 驯服
  • 哈德利·韦翰
    • 姓名:哈德利·韦翰
    • 网址:http://had.co.nz/
    • 类型:数据可视化和统计
    • 供稿:gplot2、plyr、testhat、reshape2 和 R 笔记

热门 Hadoop 贡献者

  • 迈克尔·诺尔为这本书的 Hadoop 安装步骤做出了贡献
    • 名称:Michael zero
    • 网址:http://www.michael-noll.com/
    • 类型:大数据和 Hadoop
    • 贡献:在 Hadoop 和大数据领域开发标准安装步骤和创新项目
  • 革命分析
  • 霍顿工程公司
    • 名称:霍顿工程公司
    • URL:http://hortonworks . com/
    • 类型:企业 Hadoop 解决方案
    • 适用于:100%开源和企业级分布的 Hadoop、Linux 和 Windows
    • 贡献:视窗支持和 Yarn
  • Cloudera
    • 名称:Cloudera
    • 网址:http://www.cloudera.com/
    • 类型:企业 Hadoop 解决方案
    • 适用于:面向大数据的 100%开源软件
    • 贡献:近东救济工程处
  • 雅虎！
    • 名称:雅虎！
    • 网址:http://developer.yahoo.com/hadoop/
    • 类型:企业级 Hadoop 解决方案
    • 适用于:大数据的开源软件
    • 供稿:Hadoop 开发由雅虎发起！和 OZIE
posted @ 2025-10-01 11:29  绝不原创的飞龙  阅读(2)  评论(0)    收藏  举报