【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习

目录：/Users/baidu/Documents/Data/Interview/Hadoop-Spark-Storm-Kafka

下了这本《大数据Spark企业级实战版》，

另外还有一本《Spark大数据处理：技术、应用与性能优化(全)》

先看前一篇。

 

 

 

 

根据书里的前言里面，对于阅读顺序的建议。先看最后的Scala实践三部曲吧。

 

 scala学习，我觉得这一段写的很好：

object Hello{
  def main(args: Array[String]): Unit = {
    val ret = sum(x=> x*x)(1)(2)
    println(ret)
  }

  def sum(f: Int => Int)(a: Int)(b: Int): Int =
      if (a > b) 0 else f(a) + sum(f)(a+1)(b)


}

能够看出，上面是求出从a加到b的平方和。很巧妙。

 

Scala中有两点需要注意：

1. 函数体的最后一行的值就是整个函数的返回值；

2. 类型的声明位于变量、函数或者类的后面。

 

当函数不带参数时候，我们调用的时候，可以不加括号。

 

函数还可以这样定义：

def add = (x:Int, y:Int)=>x+y

 

要注意一下Scala的柯里化，currying，允许函数定义时候有多个括号，每个括号里面一个参数。在 Haskell 中，所有的函数都是柯里化的.

科里化（柯里化）这种现象是随着函数被当做一等公民自然而然地产生的。不然高阶函数会很麻烦。

 

注意Java和Python里面，都有可变参数的，可以看我的这篇文章：http://www.cnblogs.com/charlesblc/p/6226667.html

Scala里面也有可变函数。

如下：

def abc(s: String*) = {

    s.foreach(x=>println(x))

}

然后就可以调用了

abc("I", "love", "you")

 

默认参数是这样的：

def abc(name :String = "default") : String = {

...

}

 

for循环：

查看我的这篇文章：http://www.cnblogs.com/charlesblc/p/6065424.html

 

Scala里面的面向对象

面向对象几点：

抽象和封装，继承，多态（多态也称为一个名字，多种方法）

 

注意 Scala里面的下划线，用的非常多，有个名字叫作Placeholder，下面这篇文章介绍了十几种用法：

https://my.oschina.net/leejun2005/blog/405305

没怎么看懂，慢慢领会。

 

文中用到了其中的第11中用法：

11、初始化默认值：default value var i: Int = _

 

另外，还有private[this]的使用：

class A{

private[this] val gender = "male"

}

那么在外面访问 val a = new A

a.gender 就会报错

 

看看主构造器的用法。有如下特点：

1. 主构造器直接跟在类名后面，参数会被编译成类的字段。

2. 执行时会执行类中的所有不包含在方法体中的语句。

class Person(val name: String, val age: Int) {

  println("this is constructor!")

}

运行 val p = new Person("Rocky", 27) 会打印语句。

 

注意：

class Person(name: String, val age: Int) {

}

这样的话，运行会报错，找不到name，说明没有用val或者var加载主构造器函数的话，那么这个变量是 private[this]的，只能内部访问。（那类岂不是不能初始化？）

 

附属构造器

1） 附属构造器是通过this来声明的

2) 附属构造器必须调用主构造器或者其他附属构造器。

class Person(var name : String, val age: Int) {

  var gender : String = _

  def this(name: String, age: Int, gender: String) {

    this(name, age)

    this.gender = gender

  }

}

 

继承

Scala继承用 extends来进行， 覆盖用 override来处理。

 

抽象类

abstract class A {

  def speak

}

 

另外

object AAAClass extends App {

  val worker = new Worker

  worker.speak

}

App是trait的子类，内部帮助我们实现了main方法。

 

Scala的trait

trait支持部分实现，也就是说可以在scala的trait中可以实现部分方法。

trait可以有实现的方法，也可以有抽象方法。使用trait的方式是with而混入类中。不懂。

 

子trait可以覆盖父trait中的方法，如果父trait中已经实现了方法，子trait就必须用override关键字。

 

如果既要继承类，又要继承trait，可以用 with关键字，如下：

class MyAccount extends Account with FLogger {

  def save {

    log("10000")

  }

}

其中 log 是定义在trait Flogger里面的函数。

然后在定义的时候，要这样写：

val acc = new MyAccount with MessageLogger

acc.save

上面的MessageLogger是实现了 Flogger 的trait，如下：

trait MessageLogger extends Flogger {

  override def log(msg: String) {

  }

}

 

另外，放在object里面的方法都是static方法，直接调用：

object abc {

  def func{

  }

}

abc.func

 

apply在object和class里面的应用

 

object里面可以定义apply

class A {

  def test() {

    println("test")

  }

}

 

object A {

  def apply() = new A

}

 

val a = A()

a.test

上面的 A() 直接调用 object A里面的apply()，返回了 class A，所以最后打印 "test"

 

class里面也可以定义apply

class A {

  def apply() = "hi"

}

val a = new A

println(a())

上面的 () 调用了 apply()，所以打印了"hi"

 

因为object里面的方法和属性都是static的，所以用来实现单例，很方便。

 

object A {

  def apply() = new A

  var count = 0

  def incr = {

    count = count + 1

  }

}

 

用法：

for (i <- 1 to 10) {

  A.incr

}

println(A.count)

打印了10

 

总结：object本身就是一个单例对象！！！

 

Scala函数式编程

P773

函数式编程的核心特点之一，就是把函数作为参数传给函数、在函数内部可以定义函数等。

 

1. 函数式编程定义：其实是方法论（programming paradigm）

5个特点：

1. 函数是第一等公民

2. 总用表达式 expression，不用语句statement，（意思是总有返回值）

3. 没有副作用 （避免全局变量）

4. 不修改状态（只返回新的值，不修改系统变量）

5. 引用透明（运行只依赖于输入的参数）

 

好处：

1. 代码简洁，开发迅速； 2. 接近自然语言； 3. 方便的代码管理（不依赖外界状态）4. 并发编程方便 5. 易于热升级（只要接口不变，内部实现外部无关，erlang就是为了不关机升级）

 

Scala的函数形式：

def func(var : type) : retType = {}

返回类型，有时候可以直接推断出；但是写出来更好。如果是递归的，那么返回类型必须明确写出来。

如果函数体只是一句，也可以不加花括号。

 

Unit是返回类型，指的是没有有效的返回值，有点类似于Java的void。Java中返回void的方法，会被映射成Scala返回Unit的方法。

 

值函数

值函数指的就是将一个函数赋值给一个变量进行保存，这时候变量就变成了一个函数，用的时候跟函数一样用就可以了。

def add(x:Int, y:Int):Int = (x+y)

var result = add _   （注意，把函数赋值给变量的时候，必须在后面加上空格和_）

result(1, 2) 得到3

 

匿名函数

(x:Int) => x + 3

可以赋值给一个常量：  val fun = (x: Int) => x + 3

这就相当于  def fun(x: Int) = x + 3

调用是这样的 fun(7)

 

主要用途是作为参数传递，比如：

scala.collection.mutable.ArrayBuffer(1,2,3,4).map((x:Int)=>x+3)

 

Scala中的闭包

闭包 = 代码 + 用到的非局部变量

var y = 1

val sum = (x : Int) => x + y

sum(15)

这时候y是外部变量。

 

Scala中的SAM

Java中有些接口只有单个抽象方法（Single Abstract Method）,在Java里面被称为 SAM类型。

为了在传入Java ActionListener对象的地方，传入 (ActionEvent)=>Unit函数参数，需要加一个隐式转换。

 

Scala中的Curry

柯里化，指的就是都变成一个参数的函数，新的函数返回一个以原有第二个参数为参数的函数。

def multi(x:Int) = (y: Int) => x * y

multi(6)(7)

 

柯里化可以简写成：

def multi(x:Int)(y:Int) = x * y

 

控制抽象 + 换名调用参数

可以组成不带参数也没有返回值的函数：

def runInThread(block: ()=>Unit) {

  new Thread {

    override def run() {block()}

  }.start()

}

注意：如果方法的返回类型为Unit,则可以忽略result type 和 = 号。

runInThread{ ()=> println("Hi"); Thread.sleep(10000); println("Bye")}

 

可以去掉()=>，

def runInThread(block: =>Unit) {

  new Thread {

    override def run() {block}

  }.start()

}

runInThread {println("Hi"); Thread.sleep(10000); println("Bye")}

 

Scala程序员可以构建控制抽象，看起来就像是关键字：

def until(condition: => Boolean) (block: =>Unit) {

  if (!condition) {

    block

    until(condition)(block)

  }

}

 

// 使用

var x = 10

until(x == 0) {

  x -= 1

  println(x)

}

这样的函数就叫做换名调用函数（常规的参数叫作换值调用参数）。函数在调用的时候，换名调用参数的表达式不会求值，表达式会被当做参数传递下去。

 

return表达式

P783 略

 

高阶函数

函数作为参数或作为返回值的函数称为 高阶函数。

 

val a = List(1,2,3)

这里能够直接使用List实例化对象，其实是用了List的object对象的apply方法。

 

val newList = l.map((x:Int)=>2*x)

类型一样的话可以省略类型   l.map((x)=>2*x)

只有一个参数，可以省略括号  l.map(x=>2*x)

只有一个参数，可以继续省略  l.map(_*2)

 

常见的高阶函数有 map, filter, reduce

 

1. map

array.map(1 + _) 其中的 _代表列表里面的每一个元素

 

2. filter

array.filter( _ > 33) 大于33的

 

3. reduce 

array.reduce(_ - _) 是第一个减去第二个，然后结果再减去第三个

 

Scala中的集合

主要有 List, Set, Tuple, Map等

关于 Array, List, Tuple的区别，可以看这篇文章：

https://my.oschina.net/u/1034176/blog/512314

在Scala 2.7中，Array、List都不能混合类型，只有Tuple可以；而在Scala以上版本中，3者的元素都可以混合不同的类型（转化为Any类型），只不过是当使用混合类型时，Array和List会将元素类型转化为Any类型,而Tuple则保留每一个元素的初始类型；

 

 

 

1. 1. 关于初始化

      1) Array：val array= new Array[String](3) // Array(null, null, null)相当于声明了3个null值的空元素 

      val array= Array("a","b","c","d") //  相当于 Array.apply("a","b","c","d") 

   定义一个类型为Any的Array：

    val aa = Array[Any](1, 2)或：val aa: Array[Any] = Array(1, 2)或：val aa: Array[_] = Array(1, 2)

 

2) List:

val list:List[Int] = List(1,3,4,5,6) // 或者 val list = List(1,3,4,5,6)

       (：：：)实现叠加List,(::)cons:将新元素组合到列表的最前端。元素合并使用：：，集合合并使用：：：，示例如下：其中Nil代表空元素

val list2 = "a"::"b"::"c"::Nil // Nil

    val list4 = list2:::list3

 

3) Tuple:

元组也是不可变的，但是元组可以是不同类型的数据，实例化：var a = （，）,可以通过点号，下划线，-N（N从1开始）的索引访问元素

对Tuple而言，如果只有两个元素，还可以通过下面的方式创建：

"a" -> "b"

得到：res7: (String, String) = (a, b)

 

Map类型

 Map("a"->"b", "c"->"d")

 

Option类型

Option代表一个可有可无的值。

Option有两个子类：Some 和 None . 下面我们看一下Option的使用。

 

Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。

优点大概是让有值和无值的操作变得统一吧。

 

filter的处理

 下面两个是等价的：

l.filter(x=>x %2 ==0)

l.filter(x%2 == 0)

 

看一下zip的操作

 

 

 

partition的操作 

 

 flatten 和 flatMap 的操作

 

Scala中的泛型

p790

在Scala中用 [] 来代替Java中的 <> 来表现类型参数表。

 

 

 

 

 

 

 

Scala中的隐式转换、隐式参数、隐式类

P784

 

泛型和隐式转换都看不懂。以后再看吧。

回到第13页，第一章，开始看起。

 

Spark术语

 

 

 

Spark的容错主要是 Lineage机制。 分布式数据容错主要方式有：数据检查点，和记录数据的更新。 Spark是粗粒度的记录数据的更新，只记录数据怎么从其他RDD转换而来。

 

 

 

 

 

 RDD依赖关系

 

 

Stage DAG

通常Shuffle是Stage的边界

 

看到第36页。

 

持久化与persist

通常每次运行会重新计算，如果不想重复计算，可以用 RDD.persist().  会存储在内存里（或者磁盘？）

不是必须，不应该持久化，因为浪费空间。

如果多次需要结果，可以持久化，如下：

right.persist()

right.first()

right.count()

 

另外关于 cache()，查了一下，就是全内存化的persist()，是用persist()实现的，即 persist(StorageLevel.MEMORY_ONLY)

 

创建RDD

Spark提供了两种创建RDD的方式：加载外部数据集，和在驱动程序中平行化集合。

分别是：

val lines = spark.textFile("hdfs://master:9000/input/in.txt")

和

val lines = spark.parallelize(List("pandas", "i like pandas"))

 

RDD操作

P38 下面这段讲的非常好：

 

转换和动作的示例

用take()可以检索一个小数目的结果。

还有一个collect()会输出全部结果。但是量比较大。可以使用 saveAsTextFile() 或者 saveAsSequenceFile()来存储到HDFS上。

 

惰性评估(Lazy Evaluation)

比如 sc.textFile()，数据没有被加载，只有到动作需要执行时候，才会真正加载。 

 

 

Spark子框架解析

P30 

Spark GraphX 看了一会 不懂。

 

 

Spark Stream

是按照时间节点，比如2秒，分成一段一段的，作为Dstream(Discretized Stream)，然后这一段数据转换成RDD，那么Spark Streaming对于Dstream的操作就转换成了 Spark对于RDD的操作。

流程图如下：

 

 

 

 

 

 

 

 

Spark Streaming编程模型

P55 主要是这一句：

val wordCount = words.map(x=>(x,1)).reduceByKeyAndWindow(_+_, Seconds(5s), seconds(1))

 

P57

Kafka 和 Spark Streaming结合。

 

 

Spark SQL

P58

 

 

Spark MLlib

P61

 

 

 

 

上面提到的L1和L2，在下面这篇文章讲得很好：

http://blog.csdn.net/jinping_shi/article/details/52433975

L1正则和L2正则，其实都是加在损失函数后面的一个额外项。L1正则化和L2正则化可以看做是损失函数的惩罚项。

对于线性回归模型，使用L1正则化的模型建叫做Lasso回归，使用L2正则化的模型叫做Ridge回归（岭回归）。下图是Python中Lasso回归的损失函数，式中加号后面一项α||w||1即为L1正则化项。

 

下图是Python中Ridge回归的损失函数，式中加号后面一项α||w||22即为L2正则化项。

 

一般回归分析中回归w表示特征的系数，从上式可以看到正则化项是对系数做了处理。L1正则化和L2正则化的说明如下：

• L1正则化是指权值向量w中各个元素的绝对值之和，通常表示为||w||1
• L2正则化是指权值向量w中各个元素的平方和然后再求平方根（可以看到Ridge回归的L2正则化项有平方符号），通常表示为||w||2

 

一般都会在正则化项之前添加一个系数，Python中用α表示，一些文章也用λ表示。这个系数需要用户指定。

那添加L1和L2正则化有什么用？下面是L1正则化和L2正则化的作用，这些表述可以在很多文章中找到。

• L1正则化可以产生稀疏权值矩阵，即产生一个稀疏模型，因此可以用于特征选择
• L2正则化可以防止模型过拟合（overfitting）；一定程度上，L1也可以防止过拟合

 

原因和解释，可以看上面那篇文章的原文。不细说了。

 

聚类

聚类是一种非监督学习。聚类常被用于探索性分析，或者作为层次化监督学习的一部分（聚类之后再对不同的类簇采用不同的分类器或者回归模型）。

MLLib 实现了 kmeans.

 

协同过滤

注意显性反馈与隐性反馈。

目前Spark里面可用的算法：

ALS

 

基础算法-梯度下降算法

P63

 

二元分类 线性回归 聚类 协同过滤ALS 例子

 P64

 

 

第四章 Spark RDD与编程API实战

P171

 

 

 

P193

通过 toDebugString 函数可以查看 lineage信息。

 

P195

有一个实战搜狗日志的例子，不知道是不是跟之前的实战例子类似。

 

P198

实例，按条件搜索：  

 

实例，排序，按照val排序的方式

 

 

P206

Spark支持的Transformation操作

和

Spark支持的Action操作

 

P219

Spark运行的主要流程，包括Master，Driver，Worker，DAGScheduler各自参与的工作。

 

P259

6.1 Spark内核核心术语

Application 等术语的解释和描述。

 

看到P299 GraphX 图运算 先跳过不看

 

先看P431里面的 Spark MLLib吧

还有 P665的第14章 性能调优 可以看，锦上添花那种。

 

MLLib实际对应 P443

P444介绍了机器学习的基本概念：

 

讲了各种机器学习算法。

 

P455 介绍了一个基于Spark MLLib的SVM的实例。

代码非常简洁明了。

 

P474 

MLLib经典算法案例解析（重点看线性回归、协同过滤）