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

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

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

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

先看前一篇。

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

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

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

【Todo】【读书笔记】大数据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则保留每一个元素的初始类型;

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

    1. 关于初始化

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

    2. 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开始)的索引访问元素

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

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

"a" -> "b"

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

Map类型

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

Option类型

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

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

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

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学习

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

partition的操作

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

flatten 和 flatMap 的操作

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

Scala中的泛型

p790

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

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

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

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

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

P784

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

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

Spark术语

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

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

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

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

RDD依赖关系

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

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

Stage DAG

通常Shuffle是Stage的边界

看到第36页。

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

持久化与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学习

转换和动作的示例

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

用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学习

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

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

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

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学习

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

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

http://blog.csdn.net/*_shi/article/details/52433975

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

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

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

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

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

一般回归分析中回归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学习

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

目前Spark里面可用的算法:

ALS

基础算法-梯度下降算法

P63

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

P64

第四章 Spark RDD与编程API实战

P171

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

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

P193

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

P195

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

P198

实例,按条件搜索:

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

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

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

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学习

讲了各种机器学习算法。

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

代码非常简洁明了。

P474

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

上一篇:volley框架详解


下一篇:OkHttp3源码详解(一) Request类