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

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

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

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

先看前一篇。

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第1张图片

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第2张图片

 

 

根据书里的前言里面,对于阅读顺序的建议。先看最后的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则保留每一个元素的初始类型;

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第3张图片

 

 

    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的使用。

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第4张图片

 

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

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

 

filter的处理

 下面两个是等价的:

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

l.filter(x%2 == 0)

 

看一下zip的操作

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第5张图片

 

 

partition的操作 

 

 flatten 和 flatMap 的操作

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第6张图片

 

Scala中的泛型

p790

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

 

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第7张图片

 

 

 【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第8张图片

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第9张图片

 

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

P784

 

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

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

 

Spark术语

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第10张图片

 

 

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

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第11张图片

 

 

 【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第12张图片

 

 RDD依赖关系

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第13张图片

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第14张图片

 

Stage DAG

通常Shuffle是Stage的边界

 

看到第36页。

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第15张图片

 

持久化与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 下面这段讲的非常好:

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第16张图片

 

转换和动作的示例

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第17张图片

用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的操作。

流程图如下:

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第18张图片

 

 

 

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第19张图片

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第20张图片

 【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第21张图片

 

 

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

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第22张图片

 

 

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第23张图片

 

 

上面提到的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.

 

协同过滤

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第24张图片

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

目前Spark里面可用的算法:

ALS

 

基础算法-梯度下降算法

P63

 

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

 P64

 

 

第四章 Spark RDD与编程API实战

P171

 【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第25张图片

 

 

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介绍了机器学习的基本概念

【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习_第26张图片

 

讲了各种机器学习算法。

 

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

代码非常简洁明了。

 

P474 

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

 

你可能感兴趣的:(scala,大数据,java)