2018-02-23 10:43:07 weixin_41076809 阅读数 168
  • Spark初级入门(2):解析Scala集合操作

    Scala基础入门教程,解析Scala集合操作,通过本课程的学习,能够应用Scala进行Spark应用程序开发、掌握Spark的基本运行原理及编程模型,能够熟悉运用Spark SQL进行大数据仓库的开发,掌握Spark流式计算、Spark机器学习及图计算的原理。 讲师介绍:周志湖,电子科技大学计算机软件与理论硕士研究生,研究方向为计算机视觉、机器学习,毕业后先后供职于宁波银行、中共浙江省委党校,目前就职于绿城集团,担任数据中心平台架构师、数据开发主管。Scala语言、Hadoop及Spark大数据处理技术爱好者。

    9062 人正在学习 去看看 CSDN讲师

一、机器学习架构

(1)机器学习通过算法,使用历史数据进行训练,训练完成后会产生模型,未来当有新的数据提供时,我们可以用训练产生的模型进行预测,

(2)训练数据是由Features、Label组成

Features:数据的特征,例如湿度,风向,风速,季节,气压

Label:数据的标签,也就是我们希望预测的目标,例如(0,不会下雨,1,会下雨)天气(1,晴天;2,雨天;3,阴天;4,下雪)、气温

训练阶段:训练数据是过去积累的历史数据,可能死文本文件,数据库,或者其他数据来源,经过Feather特征提取后产生Feather数据特征与Label(预测目标)经过机器学习算法的训练后产生模型

预测阶段:新输入的数据可能是(文本文件,数据库或者其他来源),经过特征提取产生Feather,使用训练完成的模型进行预测,最后产生预测结果

二、机器学习的分类(以预测天气为栗)

(1)二元分类(是非选择)

根据特征,例如湿度,风向,风速,季节,气压,希望预测目标Label只有两个选项,所以就是是非题

(2)多元分类(多选选择)

根据湿度,风向,风速,季节,气压等数据特征,预测当前的天气(1,晴天;2,雨天;3,阴天;4,下雪),希望Label有多个选项,所以像选择题

(3)回归分析(值是连续的)

我们已经知道了湿度,风向,风速,季节,气压等数据特征,希望预测当前的天气的气温,预测的目标是一个连续值,所以是计算题,对于无监督学习,从现有的数据我们不知道要预测的答案,所以没有预测目标,clustre聚类分析的目的就是讲=将数据分成几个相异性最大的群组,组群内的相似性很大

2016-10-08 11:37:00 cm_chenmin 阅读数 326
  • Spark初级入门(2):解析Scala集合操作

    Scala基础入门教程,解析Scala集合操作,通过本课程的学习,能够应用Scala进行Spark应用程序开发、掌握Spark的基本运行原理及编程模型,能够熟悉运用Spark SQL进行大数据仓库的开发,掌握Spark流式计算、Spark机器学习及图计算的原理。 讲师介绍:周志湖,电子科技大学计算机软件与理论硕士研究生,研究方向为计算机视觉、机器学习,毕业后先后供职于宁波银行、中共浙江省委党校,目前就职于绿城集团,担任数据中心平台架构师、数据开发主管。Scala语言、Hadoop及Spark大数据处理技术爱好者。

    9062 人正在学习 去看看 CSDN讲师

(文章主要来自于学习整理,好记心不如烂笔头,先记上后面再完善,欢迎大家指正交流)


监督式学习:使用有标签的训练数据(也就是已知结果的数据点)进行学习,对训练样本集外的数据进行标记(分类)预测,训练样本的标记(分类)是已知的,因此岐义性低。
 
无监督式学习:使用没有标签的训练数据(也就是已知结果的数据点)进行学习对没有概念标记(分类)的训练样本进行学习,以发现训练样本集中的结构性知识。训练标记(分类)是未知的,因此岐义性高。聚类就是典型的无监督学习
 
分类算法:
分类算法是一类监督式机器学习算法,它根据已知标签的样本来预测其它样本所属的类别,分类与回归是监督式学习的二种主要形式,监督式学习指算法尝试使用有标签的训练数据(也就是已知结果的数据点)根据对象的特征预测结果,分类与回归的区别在于预测的变量的类型:在分类中,预测的变量是离散的(也就是一个有限集中的值,叫做类别);比如:垃圾邮件与非垃圾邮件,在回归中,预测的变量是连续的,比如:根据年龄与体重预测一个人的身高


线性回归:
线性回归指用特征的线性组和来预测输出值


逻辑回归:
逻辑回归是一种二元分类方法,用来寻找一个分隔阴性与阳性示例的线性分隔平面


决策树:
决策树以节点树的形式表示,每个节点基于数据的特征作出一个二元决定(比如:这个人的年龄是否大于20?),而树的每个叶子节点则包含一种预测结果(例如:这个人是否会买一个商品?),决策树的吸引力在于模型本身容易检查,既可以进行分类也可以进行回归,一组决策树的组合称为随机森林,


聚类:
聚类是一种无监督式学习算法,用于将对象分到具有高度相似性的聚类中,主要用于数据探索以及异常检测


协同过滤:
协同过滤是一种根据用户对各种产品的交互与评分来推荐新产品的推荐系统技术,只需要输入一系列用户/产品交互记录:无论是“显式”的交互(例如:在购物网站上进行评分)还是“隐式”的(例如用户访问了一个产品的页面但没有对产品评分)交互都可以,仅仅根据这些交互,协同过滤算法就能够知道那些产品之间比较相似以及那些用户之间比较相似,然后做出推荐


过度拟合(overfitting)问题,阅读:http://blog.csdn.net/xuxurui007/article/details/9259903

2018-07-12 18:38:15 weixin_39423653 阅读数 419
  • Spark初级入门(2):解析Scala集合操作

    Scala基础入门教程,解析Scala集合操作,通过本课程的学习,能够应用Scala进行Spark应用程序开发、掌握Spark的基本运行原理及编程模型,能够熟悉运用Spark SQL进行大数据仓库的开发,掌握Spark流式计算、Spark机器学习及图计算的原理。 讲师介绍:周志湖,电子科技大学计算机软件与理论硕士研究生,研究方向为计算机视觉、机器学习,毕业后先后供职于宁波银行、中共浙江省委党校,目前就职于绿城集团,担任数据中心平台架构师、数据开发主管。Scala语言、Hadoop及Spark大数据处理技术爱好者。

    9062 人正在学习 去看看 CSDN讲师
8.3 数据探索
spark-shell --num-executors 1 --total-executor-cores 3 --executor-memory 512m

val Path = "hdfs://uti04.utidata.com:8020/u01/bigdata/"
val raw_data = sc.textFile(Path + "data/train_noheader.tsv")
# raw_data.take(2)

val records = raw_data.map(line => line.split('\t'))

records.first

records.count

records.first.size

records.first.take(2)



8.4 数据预处理
import org.apache.spark.ml.feature.{LabeledPoint, IndexToString, StringIndexer, VectorIndexer}
import org.apache.spark.ml.linalg.Vectors

# 这里注意:如果要整体复制,所有行之前都要消除空格或tab
val data = records.map{r =>
val trimmed = r.map(_.replaceAll("\"", ""))
val label = trimmed(r.size - 1).toInt
val features = trimmed.slice(4, r.size - 1).map(d => if(d=="?") 0.0 else d.toDouble)
LabeledPoint(label, Vectors.dense(features))
}

# 这里注意:如果要整体复制,所有行之前都要消除空格或tab
val nbData = records.map{r =>
val trimmed = r.map(_.replaceAll("\"", ""))
val label = trimmed(r.size - 1).toInt
val features = trimmed.slice(4, r.size - 1).map(d => if(d=="?") 0.0 else d.toDouble).map(d => if(d<0) 0.0 else d)
LabeledPoint(label, Vectors.dense(features))
}

data.take(2)

6)通过rdd创建DataFrame
val df = spark.createDataFrame(data)

val nbDF = spark.createDataFrame(nbData)

7)
scala> df.show(10)
+-----+--------------------+
|label|            features|
+-----+--------------------+
|  0.0|[0.789131,2.05555...|
|  1.0|[0.574147,3.67796...|
|  1.0|[0.996526,2.38288...|
|  1.0|[0.801248,1.54310...|
|  0.0|[0.719157,2.67647...|
|  0.0|[0.0,119.0,0.7454...|
|  1.0|[0.22111,0.773809...|
|  0.0|[0.0,1.883333333,...|
|  1.0|[0.0,0.471502591,...|
|  1.0|[0.0,2.41011236,0...|
+-----+--------------------+


# 查看nbDF的第一行数据
nbDF.head
nbDF.first

8)
scala> df.printSchema
root
|-- label: double (nullable = false)
|-- features: vector (nullable = true)


9)划分数据
val Array(trainData, testData) = df.randomSplit(Array(0.8, 0.2), seed = 1234L)

val Array(nbTrainData, nbTestData) = nbDF.randomSplit(Array(0.8, 0.2), seed = 1234L)


10)
trainData.count
testData.count

11)
trainData.cache
testData.cache
nbTrainData.cache
nbTestData.cache

12)
import org.apache.spark.ml.classification.{LogisticRegression, LogisticRegressionModel}
import org.apache.spark.ml.classification.{NaiveBayes, NaiveBayesModel}
import org.apache.spark.ml.classification.{DecisionTreeClassifier, DecisionTreeClassificationModel}

13)创建贝叶斯模型,设置初始参数
val nb = new NaiveBayes().setLabelCol("label").setFeaturesCol("features")

14)通过朴素贝叶斯训练模型,对数据进行预测
# 训练
val nbModel = nb.fit(nbTrainData)

# 预测
val nbPrediction = nbModel.transform(nbTestData)

nbPrediction.show(10)

15)准确性统计
// t1存放预测值的数组,t2存放测试数据标签值,t3存放测试数据总行数
val (t1, t2, t3) = (nbPrediction.select("prediction").collect, nbTestData.select("label").collect, nbTestData.count.toInt)

// t4为累加器
var t4 = 0

// 循环遍历, 统计正确的预测次数
for(i <- 0 to t3-1){if(t1(i)==t2(i)) t4+=1}

// 查看预测正确的个数
t4

// 计算准确率
val nbAccuracy = 1.0 * t4 / t3


8.5 组装
1)导入特征索引类
import org.apache.spark.ml.feature.{IndexToString, StringIndexer, VectorIndexer, VectorIndexerModel}

2)建立特征索引
val featureIndexer = new VectorIndexer().setInputCol("features").setOutputCol("indexedFeatures").fit(df)
 
3)建立逻辑回归模型
val lr = new LogisticRegression().setLabelCol("label").setFeaturesCol("indexedFeatures").setMaxIter(10).setRegParam(0.001)

4)创建决策树模型
# setMaxBins离散化“连续特征”的最大划分数
val dt = new DecisionTreeClassifier().setLabelCol("label").setFeaturesCol("indexedFeatures").setImpurity("entropy").setMaxBins(100).setMaxDepth(5).setMinInfoGain(0.01)

5)导入网格参数和交叉验证
import org.apache.spark.ml.tuning.{CrossValidator, ParamGridBuilder}

6)导入流水线
import org.apache.spark.ml.{Pipeline, PipelineModel}

7)导入评估器
import org.apache.spark.ml.evaluation.BinaryClassificationEvaluator

8)配置两条流水线:一条是逻辑回归的流水线,包含连个stages( featureIndexer 和lr);一条是决策树回归的流水线,包含连个stages( featureIndexer 和dt)
val lrPipeline = new Pipeline().setStages(Array(featureIndexer, lr))

val dtPipeline = new Pipeline().setStages(Array(featureIndexer, dt))

8.6 模型优化
1)分别配置网格参数,使用ParamGridBuilder构造一个parameter grid,注意无空格复制
val lrParamGrid = new ParamGridBuilder().addGrid(lr.regParam, Array(0.1, 0.3, 0.5)).addGrid(lr.maxIter, Array(10, 20, 30)).build()

val dtParamGrid = new ParamGridBuilder().addGrid(dt.maxDepth, Array(3, 5, 7)).build()

2)分别实例化交叉验证模型
val evaluator = new BinaryClassificationEvaluator

val lrCV = new CrossValidator().setEstimator(lrPipeline).setEvaluator(evaluator).setEstimatorParamMaps(lrParamGrid).setNumFolds(2)

val dtCV = new CrossValidator().setEstimator(dtPipeline).setEvaluator(evaluator).setEstimatorParamMaps(dtParamGrid).setNumFolds(2)

3)通过交叉验证模型,获取最优参数集,并测试模型
val lrCvModel = lrCV.fit(trainData)

val dtCvModel = dtCV.fit(trainData)

val lrPrediction = lrCvModel.transform(testData)

val dtPrediction = dtCvModel.transform(testData)



4)查看数据
lrPrediction.select("label", "prediction").show(10)

dtPrediction.select("label", "prediction").show(10)

5)查看逻辑回归匹配模型的参数
val lrBestModel = lrCvModel.bestModel.asInstanceOf[PipelineModel]

val lrModel = lrBestModel.stages(1).asInstanceOf[LogisticRegressionModel]

lrModel.getRegParam

lrModel.getMaxIter

6)查看决策树匹配模型的参数
val dtBestModel = dtCvModel.bestModel.asInstanceOf[PipelineModel]

val dtModel = dtBestModel.stages(1).asInstanceOf[DecisionTreeClassificationModel]

dtModel.getMaxDepth

dtModel.numFeatures

7)统计逻辑回归的预测正确性
// t_lr 为逻辑回归预测值的数组
// t_dt 为决策树预测值的数组
// t_label 为测试集的标签值的数组
val (t_lr, t_dt, t_label, t_count) = (lrPrediction.select("prediction").collect, dtPrediction.select("label").collect, testData.select("label").collect, testData.count.toInt)

//c_lr 为统计逻辑回归正确个数的累加器
//c_dt 为统计决策树正确个数的累加器
var Array(c_lr, c_dt) = Array(0, 0)

//遍历循环,统计逻辑回归正确个数
for(i <- 0 to t_count-1){if(t_lr(i)==t_label(i)) c_lr+=1}
c_lr

//统计逻辑回归正确性
1.0*c_lr/t_count

//遍历循环,统计决策树正确个数
for(i <- 0 to t_count-1){if(t_dt(i)==t_label(i)) c_dt+=1}
c_dt

//统计决策树正确性
1.0*c_dt/t_count
2019-07-07 23:52:30 weixin_43704599 阅读数 19
  • Spark初级入门(2):解析Scala集合操作

    Scala基础入门教程,解析Scala集合操作,通过本课程的学习,能够应用Scala进行Spark应用程序开发、掌握Spark的基本运行原理及编程模型,能够熟悉运用Spark SQL进行大数据仓库的开发,掌握Spark流式计算、Spark机器学习及图计算的原理。 讲师介绍:周志湖,电子科技大学计算机软件与理论硕士研究生,研究方向为计算机视觉、机器学习,毕业后先后供职于宁波银行、中共浙江省委党校,目前就职于绿城集团,担任数据中心平台架构师、数据开发主管。Scala语言、Hadoop及Spark大数据处理技术爱好者。

    9062 人正在学习 去看看 CSDN讲师

0、数据准备

var m1 = new DenseMatrix[Int](3,3,Array(1,2,3,4,5,6,7,8,9))
var m2 = new DenseMatrix[Int](3,3,Array(11,22,33,44,55,66,77,88,99))

1 4 7
2 5 8
3 6 9


11 44 77
22 55 88
33 66 99

1、调整矩阵形状

println(m1.reshape(1, 9))

1 2 3 4 5 6 7 8 9

2、矩阵转换为向量

println(m1.toDenseVector)

DenseVector(1, 2, 3, 4, 5, 6, 7, 8, 9)

3、复制下三角

 println(lowerTriangular(m1))

1 0 0
2 5 0
3 6 9

4、复制上三角

println(upperTriangular(m1))

1 4 7
0 5 8
0 0 9

5、矩阵复制

m1.copy

6、取对角线元素

println(diag(m1))

DenseVector(1, 5, 9)

7、垂直连接矩阵

println(DenseMatrix.vertcat(m1, m2))

11 44 77
22 55 88
33 66 99

8、横向连接矩阵

println(DenseMatrix.horzcat(m1,m2))

1 4 7 11 44 77
2 5 8 22 55 88
3 6 9 33 66 99

9、向量连接

2016-07-28 17:03:16 w517424787 阅读数 331
  • Spark初级入门(2):解析Scala集合操作

    Scala基础入门教程,解析Scala集合操作,通过本课程的学习,能够应用Scala进行Spark应用程序开发、掌握Spark的基本运行原理及编程模型,能够熟悉运用Spark SQL进行大数据仓库的开发,掌握Spark流式计算、Spark机器学习及图计算的原理。 讲师介绍:周志湖,电子科技大学计算机软件与理论硕士研究生,研究方向为计算机视觉、机器学习,毕业后先后供职于宁波银行、中共浙江省委党校,目前就职于绿城集团,担任数据中心平台架构师、数据开发主管。Scala语言、Hadoop及Spark大数据处理技术爱好者。

    9062 人正在学习 去看看 CSDN讲师
Spark机器学习的本质是什么?   数据+算法(迭代)
Spark的机器学习就是Spark平台上的函数库,有自己的逻辑,这些函数都是基于RDD/DataFrame/DataSet。

数据逻辑:在Spark的最底层肯定是对RDD的封装,跟版本没有关系,版本的发展只不过是提供了更多的更高的API而已,例如DataFrame、DataSet等,使用DataFrame、DataSet等一般情况下是为了使用统一的优化引擎(抽象程度越高,优化算法和空间就越大),但是机器学习从算法的角度而言,最原始的其实都是基于Vector和Matrix来进行计算的,也就是说RDD/DataFrame/DataSet等里面的数据从机器学习的角度讲都是Vector和Matrix,而借助于RDD/DataFrame/DataSet天然分布式并行计算就完成了机器学习的并行化和可扩展性等。

其实这个和图计算的思路非常相似,图计算中数据也是存储在RDD中的,但是Spark的图计算提供了
Vertices Edges、Routing Table等对象来解析RDD的数据,从而变成图计算可用的资源。

具体的图如下:



如何基于Spark 2.x讲授Spark机器学习?
1、快速巩固Spark Core的内容(2节课)
2、Vector和Matrix的学习(5节课)
3、对于Spark机器学习的每个算法:
    第一步:算法的推演过程,算法的原理
    第二步:讲解Spark是如何实现的
    第三步:案例实战
    第四步:深入思考Spark算法原理
4、最后通过综合案例实战的形式来讲解Spark算法

备注:

资料来源于:DT_大数据梦工厂(Spark发行版本定制)

更多私密内容,请关注微信公众号:DT_Spark

如果您对大数据Spark感兴趣,可以免费听由王家林老师每天晚上2000开设的Spark永久免费公开课,地址YY房间号:68917580


Spark机器学习笔记

阅读数 146

Spark机器学习笔记

博文 来自: qq_18801027
没有更多推荐了,返回首页