spark学习

最新推荐文章于 2022-11-28 18:58:17 发布
最新推荐文章于 2022-11-28 18:58:17 发布
阅读量166 收藏
点赞数
分类专栏： 技术问题 # spark 文章标签： spark 学习 scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyz0202/article/details/118359758
版权

内容参考自尚硅谷免费教学视频

Spark2.1

spark-submit的使用
  • 执行SparkPi
    在这里插入图片描述
  • 读取和写入文件：
# 1. 读取和写入本地文件系统
bin/spark-submit \
--class com.atguigu.spark.WordCount \
--master spark://master:7077 \
--executor-memory 1G \
./wordcount.jar \
file:///home/xxx/pycharm_proj/software/spark/RELEASE \
file:///home/xxx/pycharm_proj/software/spark/out
# 2. 读取和写入hdfs文件系统
bin/spark-submit \
--class com.atguigu.spark.WordCount \
--master spark://master:7077 \
--executor-memory 1G \
./wordcount.jar \
hdfs://master:9000/RELEASE \
hdfs://master:9000/out
  • 命令行解析
    • 注意几种模式：local是本地；spark(standalone)是spark自身集群；yarn-client/yarn-cluster是yarn集群，区别是是否自动分配driver进程的位置；
      在这里插入图片描述
  • SparkPi实现
// scalastyle:off println
package org.apache.spark.examples

import scala.math.random

import org.apache.spark.sql.SparkSession

/** Computes an approximation to pi */
object SparkPi {
  def main(args: Array[String]) {
    val spark = SparkSession
      .builder
      .appName("Spark Pi")
      .getOrCreate()
    val slices = if (args.length > 0) args(0).toInt else 2
    val n = math.min(100000L * slices, Int.MaxValue).toInt // avoid overflow
    val count = spark.sparkContext.parallelize(1 until n, slices).map { i =>
      val x = random * 2 - 1  /*[-1,1]即边长为2的整个正方形采样*/
      val y = random * 2 - 1
      if (x*x + y*y <= 1) 1 else 0
    }.reduce(_ + _)
    println(s"Pi is roughly ${4.0 * count / (n - 1)}")
    spark.stop()
  }
}
// scalastyle:on println
spark-standalone运行机制
  • client创建driver进程和sparkcontext，并向master注册；master调度Worker创建Executor（一个worker可以多个Executor），Executor向client注册（注意Executor只向master报告状态，而直接跟client注册）
  • client接收Executor的注册后，直接给Executor分配Task（绕过master）
  • 不同工作模式(local、standalone、yarn、mesos)，master根据设置不同对应不同的manager（driver、Executor保持不变）
    在这里插入图片描述
spark history server配置
  • spark-defaults.conf设置：设置以下两个选项，注意第二个目录要存在
    在这里插入图片描述
  • spark-env.sh设置：设置hs的访问端口，注意最后一个目录要和上面一致（下面要修改）
    在这里插入图片描述
  • 打开spark的历史服务器：sbin/start-history-server.sh，访问4000端口进行查看（注意上面配置后已经可以写，这里只是查看使用）；
spark-HA高可用配置
  • 利用zookeeper进行管理在这里插入图片描述
  • 配置在这里插入图片描述
  • 启动在这里插入图片描述
  • 在另一个节点启动新的master服务(start-master.sh)，该master会被zookeeper设置为standby（原master为alive）；当发生alive-master意外停止时，会将standby-master设置为alive，由此保证HA在这里插入图片描述在这里插入图片描述
Yarn模式安装
  • 配置：注意第一个配置为关闭内存使用检查，因为yarn检查不太准确，容易报错；当然如果资源多，可以不用关闭；在这里插入图片描述
  • 运行
    在这里插入图片描述
WordCount过程解析

在这里插入图片描述在这里插入图片描述

RDD介绍

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
note：RDD的缓存，如果有血统关系如下：A->B->C 和 A->B->D，不缓存B的话计算C/D都要从A开始计算一遍，导致A->B重复计算多遍；

RDD的转换操作学习（容易出错部分）
1. mapPartitions & mapPartitionsWithIndex
  • 例子：rdd = sc.makeRDD(1 to 10, 4)，请输出各partition的"|"拼接结果；
    // 正确写法，要注意Iterator的使用是为了满足partition的要求；
=> rdd.mapPartitions(x => Iterator(x.mkString("|"))).collect()
=>
// 错误写法
=> rdd.mapPartitions(Iterator(_.mkString("|"))) 
=> error: **missing parameter type** for expanded function ((x$1) => x$1.mkString("|"))
=>
// 例子：要求对每个partition输出 partition序号 + ":" + 各元素用"|"拼接 的结果，如 0:1|2 1:3|4|5
=> rdd.mapPartitionsWithIndex((x,y) => Iterator(x+":"+y.mkString("|"))).collect
  • 分析：
    • 上述错误写法涉及scala就近类型转换问题（又叫eta-extention）
    • 对于Iterator(_.mkString(“|”))，scala将其转换为 Iterator(x => x.mkString(“|”))，并最终转换为 y => Iterator( x => x.mkString(“|”))，此时x不知道从哪里来，因此报错；
2. flatMap
  • 例子：rdd = sc.makeRDD(1 to 10, 4)，使用flatMap进行各元素加1操作；
    => rdd.flatMap(x => Array(x+1))  
=> // 注意简写会报错；此外注意Array的使用（不一定是Array，但是要Iterable，参考源代码）
3.sample
  • 例子：rdd = sc.parallelize(1 to 20)，从中随机采样30%的数据，可重复
    => rdd.sample(true, 0.3, seed=2)
4. sortBy
  • 例子：rdd = sc.parallelize(1 to 20)，对5取余后升序
    // 注意要传入一个函数，用于生成排序的key
=> rdd.sortBy(_%5)  
=> res17: Array[Int] = Array(5, 10, 15, 20, 1, 6, 11, 16, 2, 7, 12, 17, 3, 8, 13, 18, 4, 9, 14, 19)
5. union/subtract/intersection/cartesian
  • 例子
    => val rdd = sc.parallelize(Array(1,1,2))
=> rdd.union(sc.parallelize(2 to 5)).collect  // 以下省略collect动作
=> res19: Array[Int] = Array(1, 1, 2, 2, 3, 4, 5)  // 注意没有去重
=> 
=> rdd.subtract(sc.parallelize(2 to 5))
=> res21: Array[Int] = Array(1, 1)  // 注意从前者去除后者出现的元素
=>
=> rdd.intersection(sc.parallelize(2 to 5))  // 取交集
=>
=> rdd.cartesian(sc.parallelize(2 to 5))  // 笛卡尔积
=> res23: Array[(Int, Int)] = Array((1,2), (1,3), (1,4), (1,5), (1,2), (1,3), (1,4), (1,5), (2,2), (2,3), (2,4), (2,5))
6.pipe
  • 可用于执行外部脚本；例子
    # p.sh
#!/bin/sh
echo "AA"
while read LINE; do
	echo ">>>"${LINE}
done

    // 调用上述脚本
=> sc.parallelize(1 to 3, 2).pipe("p.sh").collect
=> Array[String] = Array(AA, >>>1, AA, >>>2, >>>3)  //注意到脚本是对分区执行的，所以才只打印2次AA（2、3在同一个分区）
7. join、cogroup
  • rdd间的结合；例子
    => val rdd1 = sc.parallelize(1 to 10).map((_, 1))
=> val rdd2 = sc.parallelize(6 to 15).map((_, 1))		
// 共有部分进行拼接
=> rdd1.join(rdd2).collect
=> res25: Array[(Int, (Int, Int))] = Array((6,(1,1)), (7,(1,1)), (8,(1,1)), (9,(1,1)), (10,(1,1)))
// 左外连接：以左边rdd为基准，进行拼接（注意key是左rdd所有key）
=> rdd1.leftOuterJoin(rdd2).collect
=> res26: Array[(Int, (Int, Option[Int]))] = Array((1,(1,None)), (2,(1,None)), (3,(1,None)), (4,(1,None)), (5,(1,None)), (6,(1,Some(1))), (7,(1,Some(1))), (8,(1,Some(1))), (9,(1,Some(1))), (10,(1,Some(1))))
// 右外连接：以右边rdd为基准，进行拼接（注意key是右rdd所有key）
=> res27: Array[(Int, (Option[Int], Int))] = Array((6,(Some(1),1)), (7,(Some(1),1)), (8,(Some(1),1)), (9,(Some(1),1)), (10,(Some(1),1)), (11,(None,1)), (12,(None,1)), (13,(None,1)), (14,(None,1)), (15,(None,1)))
// cogroup：去重合并所有key，并把value转化为Iterable
=> val rdd3 = sc.parallelize(Array(0,2,4,3,3).map((_,1)))
=> val rdd4 = sc.parallelize(Array(0,1,5,3).map((_,1)))
=> rdd3.cogroup(rdd4).collect
=> res30: Array[(Int, (Iterable[Int], Iterable[Int]))] = Array((0,(CompactBuffer(1),CompactBuffer(1))), (1,(CompactBuffer(),CompactBuffer(1))), (2,(CompactBuffer(1),CompactBuffer())), (3,(CompactBuffer(1, 1),CompactBuffer(1))), (4,(CompactBuffer(1),CompactBuffer())), (5,(CompactBuffer(),CompactBuffer(1))))
8. combineByKey
  • 函数及其说明如下
    在这里插入图片描述
  • 例子：某PairRDD存储了一系列(key,value)，key可能重复，要求计算每个唯一key的平均值；
    => val rdd1 = sc.parallelize(List(("c", 1),("c", 2),("c", 3),("c", 4),("a", 10),("a", 20),("a", 30),("a", 40),("b", 50),("b", 60),("b", 70),("b", 80)))
=> val r2 = r1.combineByKey(x=>(x, 1), (x:(Int,Int),y)=>(x._1+y, x._2+1), (x:(Int,Int),y:(Int,Int))=>(x._1+y._1, x._2+y._2))
=> // 注意到上面的类型声明，不然会报错丢失类型
=> r2.collect
=> res1: Array[(String, (Int, Int))] = Array((a,(100,4)), (b,(260,4)), (c,(10,4)))
=> // 取平均
=> r2.map(x=>(x._1, x._2._1/x._2._2)).collect
=> res4: Array[(String, Int)] = Array((a,25), (b,65), (c,2))
=> // 另一种写法
=> r2.map{case (x,y)=>(x, y._1/y._2)}.collect
9. aggregateByKey
  • 函数及其说明如下：与上一个函数不同的是，该函数可以指定默认值，此后遇到任何key，都在默认值上累积，不用像上一个函数一样先初始化新key的对象；
    在这里插入图片描述
  • 例子：同上
    => val r1 = sc.parallelize(List(("c", 1),("c", 2),("c", 3),("c", 4),("a", 10),("a", 20),("a", 30),("a", 40),("b", 50),("b", 60),("b", 70),("b", 80)))
=> val r3 = r1.aggregateByKey((0,0))((x,y)=>(x._1+y, x._2+1), (x,y)=>(x._1+y._1, x._2+y._2))
=> r3.collect
=> res8: Array[(String, (Int, Int))] = Array((a,(100,4)), (b,(260,4)), (c,(10,4)))
=> // 以下求平均值同上一个例子
RDD的运行
1. RDD的宽窄依赖
  • 针对父RDD->子RDD：窄依赖就是一对一，或者多对一；宽依赖就是一对多；宽依赖发生一个父RDD的partition被shuffle到子RDD的多个partition，故称为宽依赖（可理解为很宽松地被依赖）
  • 宽窄依赖的划分用于对确定RDD的运行阶段，见下面说明
    在这里插入图片描述
2. RDD任务切分
  • 说明：
    • Application：jar包
    • Job：每个行动算子算是一个Job
    • Stage：发生宽依赖的地方划分stage
    • Task：并行度，即partition个数
      在这里插入图片描述
3. RDD的运行规划图
  • 这里主要说明stage的划分：如下图，spark是倒着进行stage的划分的，遇到宽依赖（这里是reduceByKey），则把宽依赖及其前面操作整个视为一个stage（这里是stage1），并把宽依赖前面的所有操作又视为一个stage（这里是stage2）；注意划分不含输入输出（这里是HDFS的读写操作）
    在这里插入图片描述
4. RDD的检查点机制

在这里插入图片描述

5. 键值对RDD数据分区

在这里插入图片描述

6. 数据读取与保存
  • TextFile, SequenceFile(调用HadoopFile), ObjectFile(本质上也是调用SequenceFile)
  • ObjectFile例子在这里插入图片描述
    在这里插入图片描述
  • JDBC读取sql数据
    在这里插入图片描述
7. 累加器
  • 例子
    => val sc = new SparkContext(conf)
=> var sum = 0
=> val arr = Array(1,2,3,4,5)
=> val rdd = sc.makeRDD(arr)
=> rdd.map{
 		sum += x
 		x
 		}.collect()
=> println(sum)  // 这里打印结果是0
// 问题出在 driver、executor身上，各个数据分区(如3个分区数据为[1,2],[3,4],[5])的executor都有一个sum(分别为3、7、5)，driver也有一个sum，没有拉取各executor的sum求和，所以始终为0；
// 为了解决上述问题，就需要使用累加器，代码如下
=> var sum = sc.accumulator(0)  // 改写废弃
=> // 中间部分不变
=> println(sum.value)
  • 累加器要放在行动算子里，放在转换算子可能因为多次使用该转换算子，造成重复累加；
  • 自定义行动算子
    • 以下举例 添加string的自定义累加器
    class CustomerAccu extends AccumulatorV2[String, java.util.Set[String]]{
	var logStr = new util.HashSet[String]()
	// 判断当前对象是否为空
	override def isZero: Boolean = logStr.isEmpty
	// 复制
	override def copy(): AccumulatorV2[String, util.Set[String]] = {
		val accu = new CustomerAccu
		accu.logStr.addAll(logStr)
		accu
	}
	// 重置对象
	override def reset(): Unit = logStr.clear()
	// 分区内添加数据
	override def add(v: String): Unit = logStr.add(v)
	// 合并
	override def merge(other: AccumulatorV2[String, util.Set[String]]): Unit = logStr.addAll(other.value)
	// 返回当前值
	override def value: util.Set[String] = logStr
}
// 使用该累加器
val rdd = sc.makeRDD(Array("abc", "def", "ghi", "jkl"))
val accum = new CustomerAccu
sc.register(accum, "CustomerAccu")  // 需要先注册
rdd.map{
	x =>
	accu.add(x)
	x
}.collect()
accu.value  // 内部调用copy、merge，输出上面完整Array
cyz0202
关注
专栏目录
Spark学习心得
qq_66293661的博客
05-24 1925
学习心得
spark学习资料
03-31
总的来说，Spark学习资料包括对Spark核心概念、RDD操作、Spark SQL、Spark Streaming和MLlib的全面学习，无论你是Scala还是Python开发者，都能通过这些资料深入理解和掌握Spark技术，从而在大数据处理和分析领域提升...
spark学习笔记
epitomizelu的专栏
04-15 637
1，RDD Spark 的核心是建立在统一的抽象弹性分布式数据集(RDD)
spark源码分析之submit的提交过程（一）
宁萧的博客
03-11 612
spark源码分析之submit的提交过程 1.当我们向集群提交如下命令 bin/spark-submit \ --class com.wt.spark.WordCount \ --master yarn \ WordCount.jar \ /input \ /output 2.启动脚本调用的是spark-submit，因此我们直接去看spark-submit脚本 # -z是检查后面变量是否为空（空则真） shell可以在双引号之内引用变量，单引号不可 #这一步作用是检查SPARK_HOME变量
Spark学习总结
nicole_33的博客
03-07 8024
第1章 Spark 概述 1.1 Spark是什么 Spark 是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。主要用于数据计算，经常被认为是Hadoop框架的升级版。 1.2 Spark 和Hadoop的缘分 组成： Hadoop 是由Java语言编写的，部署在分布式服务器集群上，用于存储海量数据并运行分布式分析应用的开源框架；其重要组件有，HDFS 分布式文件系统、MapReduce 编程模型、Hbase 基于HDFS的分布式数据库：擅长实时随机读/写超大规模数据集。 Spark是由Scala
Spark 学习笔记
SmartSi
07-31 1252
Spark 系统性学习笔记系列
Spark学习（1）-Spark基础
一个人的江湖
07-15 1328
定义ApacheSpark是用于大规模数据（large-scaladata）处理的统一（unified）分析引擎。Spark是一款分布式内存计算的统一分析引擎。其特点就是对任意类型的数据进行自定义计算。结构化、半结构化、非结构化等各种类型的数据结构，同时也支持使用Python、Java、Scala、R以及SQL语言去开发应用程序计算数据。Spark的适用面非常广泛，所以，被称之为统一的（适用面广）的分析引擎（数据处理）。...
Spark 学习路线
bigdata
01-05 896
参考文章： Spark 学习资源 - 知乎
Spark学习（6）-Spark SQL
一个人的江湖
11-28 3120
在RDD阶段，程序的执行入口对象是：。在Spark 2.0后，推出了对象，作为Spark编码的统一入口对象。用于SparkSQL编程作为入口对象。用于SparkCore编程，可以通过SparkSession对象中获取到。所以，后续执行环境入口对象，统一变更为SparkSession对象。2.4 SparkSession对象。
Spark学习路线
JINGXI的博客
12-29 2648
准备 编程语言介绍 scala、java、python、R都有spark对应的api，但如果想深入理解spark还是需要学习scala的。（scala中隐式转换特性可以很大程度提高spark开发效率）； Scala（FP+OP面向对象和函数式编程混合语言）优势在于函数式编程； scala是在java之外套了一层壳，编译之后还是.class，运行在jvm，所以java语言在学习大数据组建中也特别重要...
Spark学习内容介绍
若兰幽竹
03-28 860
Spark主要是内容： 通过一张图来看spark的主要内容如下： 由此可以看出，学习spark其实就是学习以上五个部分内容： 一、Spark Core （Apache Spark） 内核，是Spark中最重要的内容，相当于MapReduce, 都是进行离线计算,Spark Core的核心是：RDD（弹性分布式数据集），由分区组成。 二、Spark SQL 相当于Hive、Pig 支持SQL和DS...
spark学习文档
03-29
Spark学习文档的目的是帮助用户深入理解Spark的核心概念、工作原理以及如何在实际项目中应用Spark进行数据处理。以下是对每个文件内容的详细解读： 1. **01Spark生态和安装部署.pdf** Spark生态系统包括多个组件，...
Spark学习总结-入门
11-06
Spark是一个高效的分布式计算系统，发源...Spark立足于内存计算，相比Hadoop MapReduce，Spark在性能上要高100倍，而且Spark提供了比Hadoop更上层的API，同样的算法在Spark中实现往往只有Hadoop的1/10或者1/100的长度。
Spark 学习之路，包含 Spark Core，Spark SQL，Spark Streaming，Spark mllib 学
最新发布
05-15
Spark 学习之路，包含 Spark Core，Spark SQL，Spark Streaming，Spark mllib 学习笔记 * [spark core学习笔记及代码 * [spark sql学习笔记及代码 * [spark streaming学习笔记及代码 Spark 消息通信 ### Spark ...
统计学常用知识-Pearson相关系数-显著检验-置信区间
热门推荐
cyz0202的博客
03-22 3万+
有多种相关系数，此处介绍Pearson相关系数；以及显著检验 协方差 要理解 Pearson 相关系数，首先要理解协方差（Covariance）。方差大家可能比较熟悉，方差表示某个变量偏离均值的波动情况；而协方差表示的是两个变量 X，Y 的相互关系，其计算公式为： X=Y时，协方差即方差。可以想象，X 和 Y如果变化趋势一致时，则COV(X,Y)>0，变化趋势相反时，COV(X,Y)&...
TF-IDF特征优缺点
cyz0202的博客
04-14 1万+
本文为优缺点分析，算法的详细内容不做具体介绍；参考自该blog 标准的TF-IDF公式如下（—后的文字表示说明）： 优点：简单、快速 缺点： 仅以“词频”度量词的重要性，后续构成文档的特征值序列，词之间各自独立，无法反映序列信息； 易受数据集偏斜的影响，如某一类别的文档偏多，会导致IDF低估；处理方法如下公式所示，增加类别权重（注：最后CF(tj,ck)...
LSTM为什么比RNN好
cyz0202的博客
04-15 5406
来自知乎大佬Towser的回答，比较深刻，也加了点自己的注释，侵删 “LSTM 能解决梯度消失/梯度爆炸”是对 LSTM 的经典误解，RNN 中的梯度消失/梯度爆炸和普通的 MLP 或者深层 CNN 中梯度消失/梯度爆炸的含义不一样。MLP/CNN 中不同的层有不同的参数，各是各的梯度；而 RNN 中同样的权重在各个时间步共享，最终的梯度 g = 各个时间步的梯度 g_t 的和。（RNN反向...
C++_CUDA入门
cyz0202的博客
05-29 2760
NVIDIA CUDA入门blog-An Even Easier Introduction to CUDA
文本增强技术
cyz0202的博客
06-19 1998
参考资料熵简科技-李渔博士的报告《文本增强技术的研究进展及应用实践》 背景 本质上是增加少类样本（数量少或者类型单一）的数量 具体场景包括 少样本场景（如文本标注耗时耗力很难获取很多） 分类任务中样本不均衡（note：常见方法-欠采样 ( undersampling ) 和过采样 ( oversampling ) 会对模型带来怎样的影响？) 半监督训练（19年google半监督学习算法 UDA 可以看出[6]，文本数据增强技术可以用在无标签样本上，以构造出半监督训练所需的样本对，以此让模型从无标签的.
Scala编程入门：Spark学习笔记
"Spark学习笔记，这是一份详细记录Spark学习的笔记，包含了实践代码和解释，适合初学者。笔记中还涉及了与Spark密切相关的Scala编程语言的介绍，包括Scala的基本概念、学习Scala的原因以及简单的Scala编程示例，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值