spark编译安装
A. 如何在windows下安装配置pyspark notebook
第一步：安装anaconda
anaconda自带一系列科学计算包
接着配置环境变量：如我安装在D盘下 
B. 在linux下怎么安装spark
在windows下安装软件大家都觉得很容易，只要双击setup或是install的图标，然后跟着向导一步一步的按提示做就可以了，但是在linux下安装软件就不像windows下那样容易了，有时你找到的是没有编译过的软件源码，那就更加的麻烦了，这里就介绍一下如何安装linux的软件啦！ linux下的软件一般都是经过压缩的，主要的格式有这几种：rpm、tar、tar.gz、tgz等。所以首先拿到软件后第一件事就是解压缩。 一、在xwindow下以rpm格式的软件安装比较容易，只要在把鼠标移到文件上单击右键，在弹出的菜单里会有专门的三项（只有在右键单击rpm文件才会出现）show info，upgrade和install，这三项的意思大家都很清楚了，我就不多说了。rpm格式说了，接着就是tar，tar.gz，tgz等，在xwindow下双击这些格式的文件就会自动解压缩的，是解压缩而不是像rpm那样有install选项的，install文件会在你解压缩后才出现，不过这里我要先说一下，在你双击install前建议先好好看一下readme，因为你所要安装这些软件可能是没有编译的，所以看一下会比较好。 二、说完了xwindow下的安装和解压缩，接着说在文本模式下如何解压缩和安装，还有编译源码了。首先说rpm的，以root身份登陆后（用其他的身份登陆也可以但有些软件就不能被安装）键入rpm －i你所要解压缩的文件＋扩展名（当然是rpm）也不是很难吧，这里我要说的是“－i”意思是install，如果你想要卸载或是要执行其他的指令就打rpm －－help，看电脑给你的提示吧，为了照顾那些E文不太好的人我这里就写几个常用的参数：－e：卸载相关的应用程序，－U（注意是大写）：升级软件包， －pql：列出rpm软件包的相关信息，－qf：查找指定文件属于哪个软件包。至于那些其他格式的软件则可以用gunzip，gzip，tar和unzip等指令来解压缩，然后再运行install。通过解包后会得到一些文件，然后进入刚才解压缩后文件目录用“ls －F －color”指令看一下所得到的文件，一般有两种情况：第一种是文件为已经编译好的程序（无须再编译了）用上面的察看文件命令会以带“＊”标记的亮绿色显示；第二种则是需要由你自己编译的源代码。得到的是源代码的话，就需要我们自己编译来得到可运行的程序。编译源代码听到编译是不是就吓到你了呢，其实说穿了也就加上几句话而已，对初学者是有些困难想用好的操作系统就需要学习嘛，等你学会了在MM前露一手的时候想想吧……，在编译之前先要认真的阅读一下readme文档，老鸟们就不需要了吧，等你阅读完了以后就执行 ./configure make make install（只有Root身份才能执行此命令），编译完成之后便会在当前目录或src子目录下得到软件的可执行程序。 介绍完了，大家是不是觉的RPM的软件安装比较容易一点呢，但我个人意见初学者还是多选择RPM格式以外的软件，因为通过编译软件的源码可以为你以后编译内核打下一定的基础。
C. 如何在ipython或python中使用Spark
在ipython中使用spark
说明：
spark 1.6.0
scala 2.10.5
spark安装路径是/usr/local/spark；已经在.bashrc中配置了SPARK_HOME环境变量。
方法一
/usr/local/Spark/bin/pyspark默认打开的是Python，而不是ipython。通过在pyspark文件中添加一行，来使用ipython打开。
cp pyspark ipyspark
vi ipyspark
# 在最前面添加
IPYTHON=1
# 启动
ipyspark
方法二：
通过为spark创建一个ipython 配置的方式实现。
# 为spark创建一个ipython 配置
ipython profile create spark
# 创建启动配置文件
cd ~/.config/ipython/profile_spark/startup
vi 00-pyspark-setup.py
在00-pyspark-setup.py中添加如下内容：
import os
import sys
# Configure the environment
if 'SPARK_HOME' not in os.environ:
os.environ['SPARK_HOME'] = '/srv/spark'
# Create a variable for our root path
SPARK_HOME = os.environ['SPARK_HOME']
# Add the PySpark/py4j to the Python Path
sys.path.insert(0, os.path.join(SPARK_HOME, "python", "pyspark"))
sys.path.insert(0, os.path.join(SPARK_HOME, "python", "lib", "py4j-0.9-src.zip"))
sys.path.insert(0, os.path.join(SPARK_HOME, "python"))
启动ipython
ipython –profile spark
测试程序
在ipython中输入一下命令，如果下面的程序执行完后输出一个数字，说明正确。
from pyspark import SparkContext
sc = SparkContext( 'local', 'pyspark')
def isprime(n):
"""
check if integer n is a prime
"""
# make sure n is a positive integer
n = abs(int(n))
# 0 and 1 are not primes
if n < 2:
return False
# 2 is the only even prime number
if n == 2:
return True
# all other even numbers are not primes
if not n & 1:
return False
# for all odd numbers
for x in range(3, int(n**0.5)+1, 2):
if n % x == 0:
return False
return True
# Create an RDD of numbers from 0 to 1,000,000
nums = sc.parallelize(xrange(1000000))
# Compute the number of primes in the RDD
print 逗Result: 地, nums.filter(isprime).count()
方法三
将上面的程序放入test.py文件，执行命令python test.py。发现错误。因为没有将pyspark路径加入PYTHONPATH环境变量。
在~/.bashrc或/etc/profile中添加如下内容:
# python can call pyspark directly
export PYTHONPATH=$SPARK_HOME/python:$SPARK_HOME/python/pyspark:$SPARK_HOME/python/lib/py4j-0.9-src.zip:$PYTHONPATH
执行如下命令：
# 使配置生效
source ~/.bashrc
# 测试程序
python test.py
D. Spark sql 到底怎么搭建起来
1、spark1.0的包编译时指定支持hive： ./make-distribution.sh --hadoop 2.3.0-cdh5.0.0 --with-yarn --with-hive --tgz
2、安装完spark1.0；
3、安装与hadoop对应的CDH版本的hive；
Spark SQL 支持Hive案例：
1、将hive-site.xml配置文件拷贝到$SPARK_HOME/conf下
hive-site.xml文件内容形如：
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<property>
<name>javax.jdo.option.ConnectionURL</name>
<value>jdbc:mysql://hadoop000:3306/hive?createDatabaseIfNotExist=true</value>
</property>
<property>
<name>javax.jdo.option.ConnectionDriverName</name>
<value>com.mysql.jdbc.Driver</value>
</property>
<property>
<name>javax.jdo.option.ConnectionUserName</name>
<value>root</value>
</property>
<property>
<name>javax.jdo.option.ConnectionPassword</name>
<value>root</value>
</property>
</configuration>
2、启动spark： spark-shell
案例来源于spark官方文档： http://spark.apache.org/docs/latest/sql-programming-guide.html
//创建hiveContext
val hiveContext = new org.apache.spark.sql.hive.HiveContext(sc)
// 隐式转换
import hiveContext._
//创建hive表
hql("CREATE TABLE IF NOT EXISTS hive.kv_src (key INT, value STRING)")
//加载数据到hive表
hql("LOAD DATA LOCAL INPATH '/home/spark/app/spark-1.0.0-bin-2.3.0-cdh5.0.0/examples/src/main/resources/kv1.txt' INTO TABLE hive.kv_src")
//通过hql查询
hql("FROM hive.kv_src SELECT key, value").collect().foreach(println)
E. 如何在windows7下安装spark
其实，我想说，起初学习Hadoop的一些经验对现在学习和理解spark有了很大的帮助，尤其反反复复几次Hadoop的配置，现在linux基础指令和spark安装，比较顺手了，出错了也知道哪里遗漏了。
肯定第一步是配置spark环境：包括linux系统的安装，java，ssh，Hadoop，Scala，spark的安装与环境变量设置。虽说简单，但对于初学者说，尤其是没有使用过linux系统的，还是有些挑战。其中遗漏一些细节问题，都会出错。
第二步：java学习。会java的可以忽略，不会的建议还是学习下java，虽说可以跳过java直接学习Scala，但是Scala毕竟和java联系密切，教材中也经常拿Scala和Java做比较。掌握Java基础就行，最差就是能看懂吧。。
第三步：Hadoop学习。HDFS，MR计算框架，必须得知道吧。spark也是需要在HDFS上进行数据获取的，学习Hadoop才能知道其不足，明白spark的优势，为什么Hadoop必死。在hdfs的操作指令也必须掌握。能会写MapRece程序就再好不过了。（我还不会。。。）
第四步：Scala学习。函数式编程，重点明白这个吧。一些trait什么的使用，会java了这些都是小菜，本质一样，表达方式不同而已。所以。再次强调要学习JAVA。对我来说，不需要深入学习Scala编程，只需能看懂，而且会使用Scala操作RDD就行。后面的复杂高级编程我没学，以后用到再看。
第五步：就是spark学习。当然，最好学习spark的方式就是看官方文档，读源码，看博客（博客写的都太简单，没有特别深入的），看RDD的论文，作业如何调度，什么什么的。对于英语水平不高，阅读官方文档略困难的童鞋，推荐某研究院的spark官方文档中文翻译，还是很全的。不推荐买国内的书看，想看度娘参考下就行了，所以。英语也得提升啊。
F. debian sparkr怎么配置环境变量
1. SparkR的安装配置
1.1. R与Rstudio的安装
1.1.1. R的安装
我们的工作环境都是在Ubuntu下操作的，所以只介绍Ubuntu下安装R的方法：
1） 在/etc/apt/sources.list添加源
deb http://mirror.bjtu.e.cn/cran/bin/linux/ubuntu precise/，
然后更新源apt-get update；
2） 通过apt-get安装：
sudo apt-get install r-base
1.1.2. Rstudio的安装
官网有详细介绍：
http://www.rstudio.com/procts/rstudio/download-server/
sudo apt-get install gdebi-core
sudo apt-get install libapparmor1 # Required only for Ubuntu, not Debian
wget http://download2.rstudio.org/rstudio-server-0.97.551-amd64.deb
sudo gdebi rstudio-server-0.97.551-amd64.deb
1.2. rJava安装
1.2.1. rJava介绍
rJava是一个R语言和Java语言的通信接口，通过底层JNI实现调用，允许在R中直接调用Java的对象和方法。
rJava还提供了Java调用R的功能，是通过JRI(Java/R Interface)实现的。JRI现在已经被嵌入到rJava的包中，我们也可以单独试用这个功能。现在rJava包，已经成为很多基于Java开发R包的基础功能组件。
正是由于rJava是底层接口，并使用JNI作为接口调用，所以效率非常高。在JRI的方案中，JVM通过内存直接加载RVM，调用过程性能几乎无损耗，因此是非常高效连接通道，是R和Java通信的首选开发包。
1.2.2. rJava安装
1） 配置rJava环境
执行R CMD javareconf
root@testnode4:/home/payton# R CMD javareconf
2） 启动R并安装rJava
root@testnode4:/home/payton# R
> install.packages("rJava")
1.3. SparkR的安装
1.3.1. SparkR的代码下载
从网页下载代码SparkR-pkg-master.zip https://github.com/amplab-extras/SparkR-pkg
1.3.2. SparkR的代码编译
1） 解压SparkR-pkg-master.zip，然后cd SparkR-pkg-master/
2） 编译的时候需要指明Hadoop版本和Spark版本
SPARK_HADOOP_VERSION=2.4.1 SPARK_VERSION=1.2.0 ./install-dev.sh
至此，单机版的SparkR已经安装完成。
1.3.3. 分布式SparkR的部署配置
1） 编译成功后，会生成一个lib文件夹，进入lib文件夹，打包SparkR为SparkR.tar.gz，这个是分布式SparkR部署的关键。
2） 由打包好的SparkR.tar.gz在各集群节点上安装SparkR
R CMD INSTALL SparkR.tar.gz
至此分布式SparkR搭建完成。
2. SparkR的运行
2.1. SparkR的运行机制
SparkR是AMPLab发布的一个R开发包，为Apache Spark提供了轻量的前端。SparkR提供了Spark中弹性分布式数据集（RDD）的API，用户可以在集群上通过R shell交互性的运行job。SparkR集合了Spark 和R的优势，下面的这3幅图很好的阐释了SparkR的运行机制。
2.2. 用SparkR 进行数据分析
2.2.1. SparkR基本操作
首先介绍下SparkR的基本操作：
第一步，加载SparkR包
library(SparkR)
第二步，初始化Spark context
sc <- sparkR.init(master=" spark://localhost:7077"
,sparkEnvir=list(spark.executor.memory="1g",spark.cores.max="10"))
第三步，读入数据，spark的核心是Resilient Distributed Dataset (RDD)，RDDS可以从Hadoop的InputFormats来创建（例如，HDFS文件）或通过转化其它RDDS。例如直接从HDFS读取数据为RDD的示例如下：
lines <- textFile(sc, "hdfs://sparkR_test.txt")
另外，也可以通过parallelize函数从向量或列表创建RDD，如：
rdd <- parallelize(sc, 1:10, 2)
到了这里，那么我们就可以运用RDD的动作（actions）和转换（transformations）来对RDD进行操作并产生新的RDD；也可以很容易地调用R开发包，只需要在集群上执行操作前用includePackage读取R开发包就可以了（例：includePackage(sc, Matrix)）；当然还可以把RDD转换为R语言格式的数据形式来对它进行操作。
具体可参见如下两个链接：
http://amplab-extras.github.io/SparkR-pkg/
https://github.com/amplab-extras/SparkR-pkg/wiki/SparkR-Quick-Start
那么下面我们就通过两个示例来看下 SparkR是如何运行的吧。
2.2.2. SparkR使用举例
1） Example1：word count
# 加载SparkR包
library(SparkR)
# 初始化 Spark context
sc <- sparkR.init(master="spark://集群ip:7077"
,sparkEnvir=list(spark.executor.memory="1g",spark.cores.max="10"))
# 从HDFS上读取文件
lines <- textFile(sc, "hdfs://集群ip:8020/tmp/sparkR_test.txt")
# 按分隔符拆分每一行为多个元素，这里返回一个序列
words<-flatMap(lines,function(line) {strsplit(line,"\\|")[[1]]})
# 使用 lapply 来定义对应每一个RDD元素的运算，这里返回一个（K，V)对
wordCount <-lapply(words, function(word) { list(word, 1L) })
# 对（K，V）对进行聚合计算
counts<-receByKey(wordCount,"+",2L)
# 以数组的形式，返回数据集的所有元素
output <- collect(counts)
# 按格式输出结果
for (wordcount in output) {
cat(wordcount[[1]], ": ", wordcount[[2]], "\n")
}
2） Example2：logistic regression
# 加载SparkR包
library(SparkR)
# 初始化 Spark context
sc <- sparkR.init(master="集群ip:7077",
appName='sparkr_logistic_regression',
sparkEnvir=list(spark.executor.memory='1g',
spark.cores.max="10"))
# 从hdfs上读取txt文件， 该RDD由spark集群的4个分区构成
input_rdd <- textFile(sc,
"hdfs://集群ip:8020/user/payton/german.data-numeric.txt",
minSplits=4)
# 解析每个RDD元素的文本（在每个分区上并行）
dataset_rdd <- lapplyPartition(input_rdd, function(part) {
part <- lapply(part, function(x) unlist(strsplit(x, '\\s')))
part <- lapply(part, function(x) as.numeric(x[x != '']))
part
})
# 我们需要把数据集dataset_rdd分割为训练集（train）和测试集（test）两部分，这里
# ptest为测试集的样本比例，如取ptest=0.2，即取dataset_rdd的20%样本数作为测试
# 集，80%的样本数作为训练集
split_dataset <- function(rdd, ptest) {
#以输入样本数ptest比例创建测试集RDD
data_test_rdd <- lapplyPartition(rdd, function(part) {
part_test <- part[1:(length(part)*ptest)]
part_test
})
# 用剩下的样本数创建训练集RDD
data_train_rdd <- lapplyPartition(rdd, function(part) {
part_train <- part[((length(part)*ptest)+1):length(part)]
part_train
})
# 返回测试集RDD和训练集RDD的列表
list(data_test_rdd, data_train_rdd)
}
# 接下来我们需要转化数据集为R语言的矩阵形式，并增加一列数字为1的截距项，
# 将输出项y标准化为0/1的形式
get_matrix_rdd <- function(rdd) {
matrix_rdd <- lapplyPartition(rdd, function(part) {
m <- matrix(data=unlist(part, F, F), ncol=25, byrow=T)
m <- cbind(1, m)
m[,ncol(m)] <- m[,ncol(m)]-1
m
})
matrix_rdd
}
# 由于该训练集中y的值为1与0的样本数比值为7:3，所以我们需要平衡1和0的样本
# 数，使它们的样本数一致
balance_matrix_rdd <- function(matrix_rdd) {
balanced_matrix_rdd <- lapplyPartition(matrix_rdd, function(part) {
y <- part[,26]
index <- sample(which(y==0),length(which(y==1)))
index <- c(index, which(y==1))
part <- part[index,]
part
})
balanced_matrix_rdd
}
# 分割数据集为训练集和测试集
dataset <- split_dataset(dataset_rdd, 0.2)
# 创建测试集RDD
matrix_test_rdd <- get_matrix_rdd(dataset[[1]])
# 创建训练集RDD
matrix_train_rdd <- balance_matrix_rdd(get_matrix_rdd(dataset[[2]]))
# 将训练集RDD和测试集RDD放入spark分布式集群内存中
cache(matrix_test_rdd)
cache(matrix_train_rdd)
# 初始化向量theta
theta<- runif(n=25, min = -1, max = 1)
# logistic函数
hypot <- function(z) {
1/(1+exp(-z))
}
# 损失函数的梯度计算
gCost <- function(t,X,y) {
1/nrow(X)*(t(X)%*%(hypot(X%*%t)-y))
# 定义训练函数
train <- function(theta, rdd) {
# 计算梯度
gradient_rdd <- lapplyPartition(rdd, function(part) {
X <- part[,1:25]
y <- part[,26]
p_gradient <- gCost(theta,X,y)
list(list(1, p_gradient))
})
agg_gradient_rdd <- receByKey(gradient_rdd, '+', 1L)
# 一次迭代聚合输出
collect(agg_gradient_rdd)[[1]][[2]]
}
# 由梯度下降算法优化损失函数
# alpha ：学习速率
# steps ：迭代次数
# tol ：收敛精度
alpha <- 0.1
tol <- 1e-4
step <- 1
while(T) {
cat("step: ",step,"\n")
p_gradient <- train(theta, matrix_train_rdd)
theta <- theta-alpha*p_gradient
gradient <- train(theta, matrix_train_rdd)
if(abs(norm(gradient,type="F")-norm(p_gradient,type="F"))<=tol) break
step <- step+1
}
# 用训练好的模型预测测试集信贷评测结果（“good”或“bad”），并计算预测正确率
test <- lapplyPartition(matrix_test_rdd, function(part) {
X <- part[,1:25]
y <- part[,26]
y_pred <- hypot(X%*%theta)
result <- xor(as.vector(round(y_pred)),as.vector(y))
})
result<-unlist(collect(test))
corrects = length(result[result==F])
wrongs = length(result[result==T])
cat("\ncorrects: ",corrects,"\n")
cat("wrongs: ",wrongs,"\n")
cat("accuracy: ",corrects/length(y_pred),"\n")
G. 如何安装Spark amp;TensorflowOnSpark
安装JAVA和Hadoop
这里提供一个很好的教程，就是又好用，又好看的教程。
按照这个教程来，基本上就没有太多坑地完成安装。不过也要注意一些点。
spark从master发送命令的时候好像是按照路径寻找文件，因此你一定一定要把集群上所有的计算机的用户名都配置成一样的，比如我的都叫ubuntu，而文中的都叫hadoop，这里你要注意，如果你不跟着教程也叫hadoop的话，注意识别里面有一些命令或者路径你是不能直接复制的，而是把里面的hadoop改成你的用户名，比如在伪分布式配置core-site.xml的时候里面路径，你要改成你的实际路径才可以。
就是在按照教程配置了JAVA_HOME之后还会出现找不到JAVA_HOME的情况，应该修改hadoop/etc/hadoop/hadoop-env.sh中的JAVA_HOME的内容为绝对路径即可。
2.另外那个ssh免密登录可以不用这个，因为要搭建的是真集群的，所以这个用不着，搭好了再告诉你。这里如果不设置的话在启动hadoop的时候可能会报错在分布式下，可能会出现这种很奇怪的情况：Live nodes只有一个（应该有俩），而且你每次刷新竟然都不一样。这样的解决方法是修改hdfs-site.xml，讲data.dir改成不一样的就可以了。
集群管理器如果是新手的话建议直接使用standalone模式（如果你不知道啥是集群管理器的话，那就更这么建议了[微笑]），也就是spark自带的集群管理器，这就意味着上边那个教程里的“启动yarn”这一节你就完全可以跳过了。
然后就没什么坑了，bulabula配置好，你就拥有的伪分布式的Hadoop了，你就已经向spark迈进了一大步了。
上面那个是伪分布式的搭建，如果是想要真的分布式的话（分布式就是多台计算机的意思啦），需要看一下这个教程
照着这个教程完全修改一波，而且是每个计算机都要做相同的修改，另外这里有个小坑（也坑了我一晚上），就是如果按照最上面那个教程里搭伪分布式的话，core-site.xml这个文件的这个属性
要从localhost:9000改成master:9000<property>
<name>fs.defaultFS</name>
<value>hdfs://master:9000</value>
</property>1234
sudo tar -zxf ~/下载/spark-1.6.0-bin-without-hadoop.tgz -C /usr/local/cd /usr/localsudo mv ./spark-1.6.0-bin-without-hadoop/ ./sparksudo chown -R hadoop:hadoop ./spark # 此处的 hadoop 为你的用户名1234
cd /usr/local/sparkcp ./conf/spark-env.sh.template ./conf/spark-env.shvim conf/spark-enf.sh123
export HADOOP_HOME=/home/ubuntu/workspace/hadoopexport HADOOP_CONF_DIR=$HADOOP_HOME/etc/hadoopexport HADOOP_HDFS_HOME=/home/ubuntu/workspace/hadoopexport SPARK_DIST_CLASSPATH=$(/home/ubuntu/workspace/hadoop/bin/hadoop classpath)export JAVA_HOME=/home/ubuntu/workspace/jdk/export SCALA_HOME=/home/ubuntu/workspace/scalaexport SPARK_MASTER_IP=192.168.1.129export SPARK_WORKER_MEMORY=1Gexport SPARK_MASTER_PORT=7077export SPARK_WORKER_CORES=1export SPARK_WORDER_INSTANCES=2export SPARK_EXECUTOR_INSTANCES=2123456789101112131415161718
--conf spark.executorEnv.LD_LIBRARY_PATH="${JAVA_HOME}/jre/lib/amd64/server"
--conf spark.executorEnv.CLASSPATH="$($HADOOP_HOME/bin/hadoop classpath --glob):${CLASSPATH}" 12
安装scala和Spark
搭建好了上边的来我们进行下一个教程[微笑]
1. 安装scala最好选择一个2.10.X，这样对spark支持比较好，不会出现一些幺蛾子。这有个教程，应该是可以的
2. 安装spark大概是这里面最简单的事了吧点这里下载spark。鉴于我们已经安装好了hadoop，所以我们就下载一个不需要hadoop的spark包，就是这个with user-provided Hadoop这个
我用的是1.6.0好像大家用这个的比较多，最新的已经到2.1.x了。
解压到你想安装的目录
之后很重点的一步是修改spark-env.sh的内容，好像要改好多好多。。。
这里是我的spark-env.sh的一些配置
属性不明白的可以打开spark-env.sh，里面前面又好多注释，讲各种属性的意思。（ps:这里有个SPARK_DIST_CLASSPATH一定要照着改对，否则会运行不起来）
这是给力星大大的教程写得很好。
3. 分布式spark部署
重点来了，当然，教程在这里
这里好像没什么坑，但是好像我记得刚开始的时候别的机器上的worker老是启动不起来，但是忘记是什么原因了，可能是免密登录没设置还是怎么的。
照着教程完成了之后，你就获得了spark的集群辣，撒花~(≧▽≦)/~
ps:这里还有个搭建standalone集群的简单介绍，Spark的Standalone模式安装部署
安装TensorflowOnSpark
这个真是说难也难，说简单真是巨简单，因为步骤github上已经写得好好的了，但是，有些坑，确实会把人坑死的。
雅虎开源的TensorflowOnSpark
1. 啥？你说全是英文看不懂，好吧我也看不懂，不过你想安装TensorflowOnSpark的话，应该拉到底点这里的wiki site
然后你打开个就看见了和网站上差不多的美妙结果。
==============2017.4.15更新==================
今天在运行程序的时候发生了莫名其妙的bug，主要症状就是task会卡在某个地方不再进行了，点进去看详细的task会发现是在某个slave上的某个task卡住了，调试无果。关机重启之后再次运行不再卡顿，原因大概是系统要求的资源没有达到，以后遇到这种情况，建议重新调小运行需要的cpu数量以及内存数量等资源配置选项再试试，实在不行就关机重启，一般都可以解决
==============2017.7.28更新====================
又踩到一个坑是，还是在识别的时候可能会卡住，可能是因为其他的worker中的namenode忘记format了。
另外还有识别的准确率很低的问题，可能是因为python找不到Jar包了，使用以下方法可以：
原来python在写hdfs文件的时候，找不到对应的jar包，在提交的时候添加如下的配置信息
这里致谢评论区中的“她说巷尾的樱花开了 2017-07-13 10:10发表 [回复]“ 提供解决方法
相关链接：
利用IDEA查看和修改spark源码
修改spark源码并编译部署