Hadoop-和-R-大数据分析-二-Hadoop 和 R 大数据分析（二）五、使用 R 和 Hadoop 学习数据分

Hadoop 和 R 大数据分析（二）

原文：Big Data Analytics with R and Hadoop

协议：CC BY-NC-SA 4.0

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

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

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

在本章中，我们将了解:

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

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

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

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

Understanding the data analytics project life cycle

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

识别问题

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

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

设计数据需求

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

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

数据预处理

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

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

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

对数据进行分析

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

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

可视化数据

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

ggplot2:这个是哈德利·韦翰博士(had.co.nz/)对《图形的语法》的实现。更多信息请参考cran.r-project.org/web/package…。
rCharts:这是一个 R 包，通过使用由马库斯·格斯曼和迭戈·德·卡斯蒂略设计的熟悉的点阵式绘图界面，从 R 中创建、定制和发布交互式 JavaScript 可视化效果。更多信息请参考ramnathv.github.io/rCharts/。

使用 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:
Dashboard charts: This is an rCharts type. Using this we can build interactive animated dashboards with R.

了解数据分析问题

在本节中，我们包括了三个实际的数据分析问题，这些问题与使用 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

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

通过设置 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()

将数据集上传至 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:

上一个截图中的输出仅用于获取关于这个 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.
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.
Tracking HDFS output location: Once the MapReduce job is completed, its output location will be displayed at the end of logs.

对于 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.
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.
Tracking HDFS output location: Once the MapReduce job is completed, its output location will be displayed at the end of the logs.

这个链式 MapReduce 作业的输出存储在 HDFS 的一个位置，可以通过以下命令检索:

from.dfs(output)

下图显示了对前面命令的响应(仅输出数据集的前 1000 行):

Performing analytics over data

可视化数据

我们使用这三个类别收集了网页分类输出。我认为我们能做的最好的事情就是简单地列出网址。但是如果我们有更多的信息，比如来源，我们可以将网页表示为一个图的节点，当用户跟随链接时，通过有向边的流行度来着色。这可以带来更丰富的见解。

计算股市变化的频率

这个数据分析 MapReduce 问题是为了计算股市变化的频率而设计的。

识别问题

由于这是一个典型的股票市场数据分析问题，它将计算股票市场的一个特定符号过去变化的频率，例如傅立叶变换 。基于这些信息，投资者可以获得更多关于不同时期变化的见解。所以这个分析的目标是计算百分比变化的频率。

Identifying the problem

设计数据需求

对于这个股市分析，我们将使用雅虎！财务作为输入数据集。我们需要检索特定符号的股票信息。为了检索这些数据，我们将使用雅虎！具有以下参数的应用编程接口:

从月份开始
从那天开始
从年
到月
今天
到年
标志

类型

更多关于这个 API 的信息，请访问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.
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.
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.
从终端，可以使用以下命令调用 Hadoop MapReduce 程序的输出:
```
bin/hadoop dfs -cat /stock/outputs/part-00000
```
您的 MapReduce 程序输出的标题如下所示:
```
change    frequency
```
The following figure shows the sample output of MapReduce problem:

可视化数据

如果我们用 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 个训练数据点。每个数据点代表销售的各种属性、推土机的配置和销售价格。为了找到预测销售价格的地方，需要实现随机森林回归模型。

注

本次卡格尔比赛的参考链接是www.kaggle.com/c/bluebook-…。您可以查看数据、信息、论坛和排行榜，还可以探索其他一些大数据分析竞赛，并参加这些竞赛来评估您的数据分析技能。

我们选择这个模型是因为我们对从大数据集的随机集合中预测数值形式的销售价格感兴趣。

数据集以下列数据文件的形式提供:

文件名

描述格式(大小)

| | --- | --- | | 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
Normal fitting: In this cross-validation and training errors are normal
Over fitting: In this the cross-validation error is high but training error is low

我们将使用机器学习的随机森林技术对数据拟合模型。这是一种递归分区方法，特别适合小型和大型问题。它涉及分类(或回归)树的集合(或集合)，这些树是在数据的随机子集上计算的，对每个分类树中的每个分割使用随机限制和选择的预测器的子集。

此外，分类/回归树的集合的结果已经被用来产生更好的预测，而不是仅仅使用一个分类树的结果。

我们现在将使用 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 ² - （Sx） ² ）
The intercept point of regression is given by:

e = （Σy - b（Σx）） / N

这里， x 和 y 是构成数据集的变量， N 是数值的总数。

假设我们有下表所示的数据:

| | --- | --- | | Sixty-three | Three point one | | Sixty-four | Three point six | | Sixty-five | Three point eight | | Sixty-six | four |

如果我们有一个新的值 x ，我们可以借助回归公式得到 y 的值。

线性回归的应用包括:

销售预测
预测最佳产品价格
预测各种来源和活动的下一次在线购买

让我们看一下为所提供的数据集实现回归模型的统计技术。假设我们得到了 n 个统计数据单元。

Linear regression

其公式如下:

y = e₀+a₀x₀+a₁x₁+a₂x₂+a₃x₃+a₄x₄

这里 Y 是目标变量(响应变量) xi 是解释变量e₀T9】是平方误差项之和，可以认为是噪声。为了得到更准确的预测，我们需要借助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)²。
自由度 ( 自由度):用于识别预测模型的拟合程度，应尽可能小(逻辑上，值 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 的信息，请访问github.com/RevolutionA…。在 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)))

线性回归算法的概要如下:

用 MapReduce 作业 1 计算Xtx值。
用 MapReduce 作业 2 计算Xty值。
用Solve (Xtx, Xty)导出系数值。

让我们逐一了解这些步骤。

第一步是用 MapReduce 作业 1 计算Xtx值。

大矩阵以整行的块传递给映射器。为这些子矩阵计算较小的叉积，并传递给单个 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]]

当 Hadoop 分布式文件系统 ( HDFS 中存储了大量数据时，我们需要将其路径值传递给MapReduce方法中的输入参数。
在前面的代码中，我们看到X是设计矩阵，它是用以下函数创建的:
```
X = matrix(rnorm(2000), ncol = 10)
```
Its output will look as shown in the following screenshot:

因此，这里所有的列都将被视为解释变量，它们的标准误差可以用类似于我们用正态线性回归计算它们的方式来计算。

使用 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)导出系数值，请使用以下步骤:

最后，我们只需要调用下面一行代码就可以得到系数值。
```
solve(XtX, Xty)
```
The output of the preceding command will be as shown in the following screenshot:

逻辑回归

在统计学中，逻辑回归或 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 = e^logit(p)1+e^logit(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 个 ⁶ 点和 10 个 ² 五维中心。

# 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:

总结

在这一章中，我们学习了如何在 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 的安装步骤。

使用以下命令配置包管理系统(APT):

sudo apt-key adv --keyserverhkp://keyserver.ubuntu.com:80 --recv 7F0CEB10

使用以下命令创建/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

现在，使用以下命令更新操作系统的软件包列表:
```
sudo apt-get update
```
使用以下命令安装最新版本的 MongoDB:
```
apt-get install mongodb-10gen
```

现在，我们将看到 CentOs 的安装步骤。

配置包管理系统。

创建/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

安装软件包。

使用以下命令，安装 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 的步骤:

下载 Hbase 的 tar 文件并提取:

wget http://apache.cs.utah.edu/hbase/stable/hbase-0.94.11.tar.gz

tar -xzf hbase-0.94.11.tar.gz

转到 HBase 安装目录，更新配置文件:

cd hbase-0.94.11/

vi conf/hbase-site.xml

修改配置文件:

更新hbase-env.sh。
```
~ Vi conf / hbase-env.sh 
```

设置糖化血红蛋白的配置:

 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

更新hbase-site.xmlzxml :
```
Vi conf / hbase-site.xml
```

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>

类型

如果使用单独的电动开闭机设置，则需要更改配置。

复制 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

安装节俭

以下是安装节电器的步骤:

从网上下载节俭源，放到客户端。我们将用 Ubuntu O.S 12.04:
```
get http://archive.apache.org/dist/thrift/0.8.0/thrift-0.8.0.tar.gz
```
来做
要提取下载的.tar.gz文件，请使用以下命令:
```
tar xzvf thrift-0.8.0.tar.gz
cd thrift-0.8.0/
```
编译配置参数:
```
./Configure
```
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 包来加载数据、更新以及查询数据来分析它们。

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