Spark（开课吧笔记）

2016.07.14

1-Spark实战演练：Spark概述及生态环境

2.Spark实战演练：Spark vs Hadoop MapReduce

任意一条边有方向且不存在环路的图，一次执行所有这些图的任务节点，而不需要一个个按照顺序来进行，这个方案避免了mapreduce中麻烦的同步问题，应用程序构建简单。

创新：1支持跨DAG的内存数据分享，不同任务处理相同的数据

2支持循环数据流，很好处理迭代图算法、机器学习和流处理，如社交网络分析

引人注目：1内存使用，MR需要处理磁盘的数据，而spark可充分利用分散在集群中所有节点的大量RAM

2智能利用池磁盘，解决预存数据和持久性问题，RDD可以cache到内存当中，结果也存到内存，下次操作直接从内存中读取，机器学习算法大量迭代效率的提示大

使用scala语言，使用大量函数式编程的思想，提供丰富RDD操作API

3-Spark实战演练：在单机上安装和运行Spark

解压缩

环境变量
1. Vim（需要熟悉操作）
  
  2.Java
  
  添加如下安装目录内容
启动时才加载，强制加载（source）

验证

3.scala

运算一下

4.spark

Spark内部已集成了简单的应用

计算pi测试一下参数是参加了多少次迭代的计算

安装Python模块

Numpy数学库

测试

4-在Sdandalone和YARN上部署Spark集群

分别在集群的每台机器安装spark，再启动相应master和slave

使用spark客户端向yarn提交任务运行。部署方式：1.将spark部署包放到yarn集群某个节点上面2.yarn客户端读取yarn集群配置文件，在此过程中，spark的master和slave节点不需要启动

Yarn（淘宝团队）mesos（豆瓣）

IP180为master，4个slave

1.4台部署好hdfs

检测

检查所有机器（hadoop，spark）

检查环境变量

Spark配置文件

编辑slaves

填ip

检查其他机器

配置spark-env.sh

启动

Master

Slave

启动所有

停止

运行

本机

集群运行

参数值：

Spark on Yarn部署

Hadoop、spark部署完成

测试一下

./spark-submit --class (提交类名)org.apche.spark.examples.SparkPi --master(提交方式) yarn-cluster ../lib/spark-examples*.jar

只需在配置文件填写一行配置，不需要自己管理 master和slave关系，原因yarn作为资源调度框架已经帮我们做好了这些，只需调用yarn-cluster，指定example

主要关心这个日志信息

再提交一次对比

说明yarn帮我们管理真正输出的机器节点

也可用命令行查看结果

输出结果为

PS:额外example

对比localPI和sparkPi

5-Spark实战演练：使用Spark Shell

关掉日志

3个日志等级WARN、ERROR、INFO

设置成WARN可将log日志去掉

重新启动加载

使用map

根据空格进行分割，147行的文章

使用reduce

当两两归并，单词比较多的选出来。结果为文章中最长的一行有65个单词。

调用Java类库

WordCount

map(word=>(word,1))，只要Word出现就map为1

下划线_是scala匿名参数的形式

WordCount

Cache强制加入内存，不需要计算前面的filter。

Cache将初步计算的结果强制存储在内存中

6-Scala语言介绍

安装JDK和Scala

Scala新特性

1.打印整数，字符串

2.常量和变量

变量重复定义（不建议）

3.布尔值

4. 函数

5.map

6.Flatmap

7.匿名参数

将list里面的值加10

Map遍历list所有元素中_下划线代表匿名参数为遍历的每个元素

8.foreach

9.数组

10.set集合

用于去重

11.hashMap

Key->value

类型转换

12元组tuple

scala> val a =(1,2)

a: (Int, Int) = (1,2)

scala> val b=(a,2,"three")

b: ((Int, Int), Int, String) = ((1,2),2,three)

使用元组特性除法获得商和余数

13复杂的情况

14类似RDDapi操作

匿名参数_,大于10的操作

15使用java类库

1和9比较，然后1和49再比较

16for循环

17While与do while

18If

19字符串操作

20类操作

class Point(xc:Int,yc:Int)

{

var x:Int=xc

var y:Int=yc

def move(dx: Int,dy: Int)

{

x = x + dx

y = y + dy

}

override def toString():String = "(" + x+"," +y +")";

}

object MovePoint{

def main(args:Array[String])

{

var p = new Point(2,3)

p.move(3,5)

println(p.toString)

}

7-使用Python编写Spark程序

8-创建SparkContext

所用RDD操作都是基于SparkContext，比如从cluster中读取数据，使用sparkShell时，系统会自动创建SparkContext，并命名为sc。

自己编写时，创建SparkContext

appName相当于应用名称将在webUi监控中显示，方便查找任务

master用于指定连接的spark、yarn、messos集群中的URL字符串

9-RDD简介

弹性分布数据集

通过调用SparkContext的parallelize方法，在已经存在的scala集合集合的对象会被拷贝出来创建一个可以被并行处理的分布式数据集distData。distData.reduce((a,b)=>a+b),对数据集求和。

并行集合重要的参数：

slize的数目=数据集切分的份数，spark在集群上为每一个份数起一个任务，集群的每个CPU分配2-3个slize（spark会根据集群的状况设置slize的数目，也可以设置parallelize的第二个参数手动设置）

最重要功能：

不同的工作间持久化数据集到内存中，持久化一个RDD，每个节点都将把它的计算结果保存到内存当中，并对此数据集后续计算中重用（对后续的工作变得高效，缓存spark迭代算法的关键）。可以用prist或cache持久化一个RDD，如果被一个动作触发计算，将会被保存到计算节点的内存中，并被重用，cache有容错机制，如果RDD任意的分区丢失，通过使用原先的转换transformation操作，自动重算丢失部分，不需要全部重算；每个RDD都可以使用不同的保存级别进行保存，除了在硬盘上进行数据集的持久化，或者在内存中序列化Java对象或者跨节点复制，这些等级选择是同过StorageLevel对象传递给prist方法确定，cache使用默认存储级别，只使用内存的存储方法，StorageLevel的MEMORY_ONLY方法

实践

指定master

val lines =sc.textFile("/spark/data/Spark-QuickStart")

val lineLength =lines.map(s => s.length)

val totalLength = lineLength.reduce((a,b) => a+b)

Spark惰性功能，对于action操作才会从第一步开始进行运算

persist操作

wordCount

scala> val words =lines.flatMap(x=>x.split(" ")).map(w => (w,1)).reduceByKey((a,b) => a+b)

words: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[503] at reduceByKey at <console>:33

scala> words.filter(_._1 == "Scala").collect

res26: Array[(String, Int)] = Array((Scala,8))

scala>val words_count =lines.flatMap(x=>x.split(" ")).map(w => (w,1)).reduceByKey((a,b) => a+b)

scala>val words_count1 =lines.flatMap(x=>x.split(" ")).map(w => (w,1)).countByKey()

scala>words_count1("Scala")

res27: Long = 8

10-RDD操作——Transformation

Transformation都是采用惰性策略，任务提交后只是记录下对数据集进行何种Transformation操作，也就是一个工作流程，只有后续Actions时才触发，对一个很大数据集进行map操作，再进行reduce操作，只需要将reduce操作后的结果返回spark驱动程序，而不包括map中间结果。

持久化包括内存，硬盘和跨多个节点的存储

Map需要做很重的初始化和结束操作（连接数据库和关闭连接），这些操作都是对每个元素进行的，mapPartition是更好的选择，可对每个partition进行一次操作。

11-RDD操作——Action

12-RDD操作——共享变量

13-Spark SQL介绍

14-Spark SQL——Running SQL on RDDs

15-Spark SQL——Using Parquet & JSON

16-Spark SQL——Hive支持

17-Spark MLlibs介绍

18-LinearRegression

数据目录spark-1.6.2\data\mllib\ridge-data\lpsa.data

Vetor分稀疏的和普通的

稀疏矩阵，在SparseVector里面绝大多部分的数值为0，对于那些多余的0我们不需要存储，有坐标和坐标对应的值数组组成，SparseVecto实现上只保存非0的数值，没保存就是默认为0。

可以看成double的数组

导包

import
org.apache.spark.mllib.regression.LabeledPoint

import
org.apache.spark.mllib.regression.LinearRegressionModel

import
org.apache.spark.mllib.regression.LinearRegressionWithSGD

import
org.apache.spark.mllib.linalg.Vectors

// Load and parse the data

val data = sc.textFile("data/mllib/ridge-data/lpsa.data")

val parsedData = data.map { line =>

val parts = line.split(',')//将数据每一行以，逗号切分

LabeledPoint(parts(0).toDouble,
Vectors.dense(parts(1).split(' ').map(_.toDouble)))//
第1个参数parts）以空格进行分割，将array里面的数据转换成Double。

}.cache()

用model对trainingdata进行预测

真正的方差还需要开方

总结：方差比较大，model失真度比较大。原因：1.数据量比较小。2.数据不是很符合线性的模型，很难train出合适的模型

19-K-Means

20-Collaborative Filtering