实验六 Spark机器学习库MLlib编程初级实践

已于 2024-05-13 19:04:43 修改
阅读量1.7k 收藏 33
点赞数 22
文章标签： spark 机器学习 mllib
于 2024-05-13 18:25:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67722961/article/details/138814060
版权

1 实验目的

（1）通过实验掌握基本的MLLib编程方法；

（2）掌握用MLLib解决一些常见的数据分析问题，包括数据导入、成分分析和分类和预测等。

2 实验平台

操作系统：Ubuntu16.04及以上

JDK版本：1.8或以上版本

Spark版本：3.4.0

数据集：下载Adult数据集(http://archive.ics.uci.edu/ml/datasets/Adult)，该数据集也可以直接到本教程官网的“下载专区”的“数据集”中下载。数据从美国1994年人口普查数据库抽取而来，可用来预测居民收入是否超过50K$/year。该数据集类变量为年收入是否超过50k$，属性变量包含年龄、工种、学历、职业、人种等重要信息，值得一提的是，14个属性变量中有7个类别型变量。

3 实验要求

1.数据导入

从文件中导入数据，并转化为DataFrame。

2.进行主成分分析（PCA）

对6个连续型的数值型变量进行主成分分析。PCA（主成分分析）是通过正交变换把一组相关变量的观测值转化成一组线性无关的变量值，即主成分的一种方法。PCA通过使用主成分把特征向量投影到低维空间，实现对特征向量的降维。请通过setK()方法将主成分数量设置为3，把连续型的特征向量转化成一个3维的主成分。

3.训练分类模型并预测居民收入

在主成分分析的基础上，采用逻辑斯蒂回归，或者决策树模型预测居民收入是否超过50K；对Test数据集进行验证。

4.超参数调优

利用CrossValidator确定最优的参数，包括最优主成分PCA的维数、分类器自身的参数等。

4 实验内容和步骤（操作结果要附图）

从文件中导入数据，并转化为DataFrame。

在进行数据导入前，要先对所下载的adult数据集进行预处理

//导入需要的包

import org.apache.spark.ml.feature.PCA

import org.apache.spark.sql.Row

import org.apache.spark.ml.linalg.{Vector,Vectors}

import org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator

import org.apache.spark.ml.{Pipeline,PipelineModel}

import org.apache.spark.ml.feature.{IndexToString, StringIndexer, VectorIndexer,HashingTF, Tokenizer}

import org.apache.spark.ml.classification.LogisticRegression

import org.apache.spark.ml.classification.LogisticRegressionModel

import org.apache.spark.ml.classification.{BinaryLogisticRegressionSummary, LogisticRegression}

import org.apache.spark.sql.functions;

//获取训练集测试集（需要对测试集进行一下处理，adult.data.txt的标签是>50K和<=50K，而adult.test.txt的标签是>50K.和<=50K.，这里是把adult.test.txt标签中的“.”去掉了）

import spark.implicits._

scala> import spark.implicits._

import spark.implicits._

 case class Adult(features: org.apache.spark.ml.linalg.Vector, label: String)

scala> case class Adult(features: org.apache.spark.ml.linalg.Vector, label: String)

defined class Adult

（路径要存在HDFS上，记得打开Haadoop）

val df = sc.textFile("hdfs://localhost:9000/user/hadoop/adult.data.txt").map(_.split(",")).map(p => Adult(Vectors.dense(p(0).toDouble,p(2).toDouble,p(4).toDouble, p(10).toDouble, p(11).toDouble, p(12).toDouble), p(14).toString())).toDF()

scala> val df = sc.textFile("hdfs://localhost:9000/user/hadoop/adult.data.txt").map(_.split(",")).map(p => Adult(Vectors.dense(p(0).toDouble,p(2).toDouble,p(4).toDouble, p(10).toDouble, p(11).toDouble, p(12).toDouble), p(14).toString())).toDF()

val test = sc.textFile("hdfs://localhost:9000/user/hadoop/adult.test.txt").map(_.split(",")).map(p => Adult(Vectors.dense(p(0).toDouble,p(2).toDouble,p(4).toDouble, p(10).toDouble, p(11).toDouble, p(12).toDouble), p(14).toString())).toDF()

scala> val test = sc.textFile("hdfs://localhost:9000/user/hadoop/adult.test.txt").map(_.split(",")).map(p => Adult(Vectors.dense(p(0).toDouble,p(2).toDouble,p(4).toDouble, p(10).toDouble, p(11).toDouble, p(12).toDouble), p(14).toString())).toDF()

对6个连续型的数值型变量进行主成分分析。

PCA（主成分分析）是通过正交变换把一组相关变量的观测值转化成一组线性无关的变量值，即主成分的一种方法。

PCA通过使用主成分把特征向量投影到低维空间，实现对特征向量的降维。

通过setK()方法将主成分数量设置为3，把连续型的特征向量转化成一个3维的主成分。

构建PCA模型，并通过训练集进行主成分分解，然后分别应用到训练集和测试集

al pca = new PCA().setInputCol("features").setOutputCol("pcaFeatures").setK(3).fit(df)

scala> val pca = new PCA().setInputCol("features").setOutputCol("pcaFeatures").setK(3).fit(df)

17/09/07 17:43:04 WARN BLAS: Failed to load implementation from: com.github.fommil.netlib.NativeSystemBLAS

17/09/07 17:43:04 WARN BLAS: Failed to load implementation from: com.github.fommil.netlib.NativeRefBLAS

17/09/07 17:43:04 WARN LAPACK: Failed to load implementation from: com.github.fommil.netlib.NativeSystemLAPACK

17/09/07 17:43:04 WARN LAPACK: Failed to load implementation from: com.github.fommil.netlib.NativeRefLAPACK

pca: org.apache.spark.ml.feature.PCAModel = pca_22d742dc5c91

 val result = pca.transform(df)

scala> val result = pca.transform(df)

result: org.apache.spark.sql.DataFrame = [features: vector, label: string ... 1 more field]

 val testdata = pca.transform(test)

scala> val testdata = pca.transform(test)

testdata: org.apache.spark.sql.DataFrame = [features: vector, label: string ... 1 more field]

  

result.show(false)

scala> result.show(false)

+------------------------------------+------+-----------------------------------------------------------+

|features                            |label |pcaFeatures                                                |

+------------------------------------+------+-----------------------------------------------------------+

|[39.0,77516.0,13.0,2174.0,0.0,40.0] | <=50K|[77516.0654328193,-2171.6489938846585,-6.9463604765987625] |

|[50.0,83311.0,13.0,0.0,0.0,13.0]    | <=50K|[83310.99935595776,2.526033892790795,-3.38870240867987]    |

|[38.0,215646.0,9.0,0.0,0.0,40.0]    | <=50K|[215645.99925048646,6.551842584546877,-8.584953969073675]  |

|[53.0,234721.0,7.0,0.0,0.0,40.0]    | <=50K|[234720.99907961802,7.130299808613842,-9.360179790809983]  |

|[28.0,338409.0,13.0,0.0,0.0,40.0]   | <=50K|[338408.9991883054,10.289249842810678,-13.36825187163136]  |

|[37.0,284582.0,14.0,0.0,0.0,40.0]   | <=50K|[284581.9991669545,8.649756033705797,-11.281731333793557]  |

|[49.0,160187.0,5.0,0.0,0.0,16.0]    | <=50K|[160186.99926937037,4.86575372118689,-6.394299355794958]   |

|[52.0,209642.0,9.0,0.0,0.0,45.0]    | >50K |[209641.99910851708,6.366453450443119,-8.38705558572268]   |

|[31.0,45781.0,14.0,14084.0,0.0,50.0]| >50K |[45781.42721110636,-14082.596953729324,-26.3035091053821]  |

|[42.0,159449.0,13.0,5178.0,0.0,40.0]| >50K |[159449.15652342222,-5173.151337268416,-15.351831002507415]|

|[37.0,280464.0,10.0,0.0,0.0,80.0]   | >50K |[280463.9990886109,8.519356755954709,-11.188000533447731]  |

|[30.0,141297.0,13.0,0.0,0.0,40.0]   | >50K |[141296.99942061215,4.2900981666986855,-5.663113262632686] |

|[23.0,122272.0,13.0,0.0,0.0,30.0]   | <=50K|[122271.9995362372,3.7134109235547164,-4.887549331279983]  |

|[32.0,205019.0,12.0,0.0,0.0,50.0]   | <=50K|[205018.99929839539,6.227844686207229,-8.176186180265503]  |

|[40.0,121772.0,11.0,0.0,0.0,40.0]   | >50K |[121771.99934864056,3.6945287780540603,-4.918583567278704] |

|[34.0,245487.0,4.0,0.0,0.0,45.0]    | <=50K|[245486.99924622496,7.4601494174606815,-9.75000324288002]  |

|[25.0,176756.0,9.0,0.0,0.0,35.0]    | <=50K|[176755.9994399727,5.370793765347799,-7.029037217537133]   |

|[32.0,186824.0,9.0,0.0,0.0,40.0]    | <=50K|[186823.99934678187,5.675541056422981,-7.445605003141515]  |

|[38.0,28887.0,7.0,0.0,0.0,50.0]     | <=50K|[28886.99946951148,0.8668334219437271,-1.2969921640115318] |

|[43.0,292175.0,14.0,0.0,0.0,45.0]   | >50K |[292174.9990868344,8.87932321571431,-11.599483225618247]   |

+------------------------------------+------+-----------------------------------------------------------+

only showing top 20 rows

  

 testdata.show(false)

scala> testdata.show(false)

+------------------------------------+-------+-----------------------------------------------------------+

|features                            |label  |pcaFeatures                                                |

+------------------------------------+-------+-----------------------------------------------------------+

|[25.0,226802.0,7.0,0.0,0.0,40.0]    | <=50K.|[226801.99936708904,6.893313042325555,-8.993983821758796]  |

|[38.0,89814.0,9.0,0.0,0.0,50.0]     | <=50K.|[89813.99938947687,2.7209873244764906,-3.6809508659704675] |

|[28.0,336951.0,12.0,0.0,0.0,40.0]   | >50K. |[336950.99919122306,10.244920104026273,-13.310695651856003]|

|[44.0,160323.0,10.0,7688.0,0.0,40.0]| >50K. |[160323.23272903427,-7683.121090489607,-19.729118648470976]|

|[18.0,103497.0,10.0,0.0,0.0,30.0]   | <=50K.|[103496.99961293535,3.142862309150963,-4.141563083946321]  |

|[34.0,198693.0,6.0,0.0,0.0,30.0]    | <=50K.|[198692.9993369046,6.03791177465338,-7.894879761309586]    |

|[29.0,227026.0,9.0,0.0,0.0,40.0]    | <=50K.|[227025.99932507655,6.899470708670979,-9.011878890810314]  |

|[63.0,104626.0,15.0,3103.0,0.0,32.0]| >50K. |[104626.09338764261,-3099.8250060692035,-9.648800672052692]|

|[24.0,369667.0,10.0,0.0,0.0,40.0]   | <=50K.|[369666.99919110356,11.241251385609905,-14.581104454203475]|

|[55.0,104996.0,4.0,0.0,0.0,10.0]    | <=50K.|[104995.9992947583,3.186050789405019,-4.236895975019816]   |

|[65.0,184454.0,9.0,6418.0,0.0,40.0] | >50K. |[184454.1939240066,-6412.391589847388,-18.518448307264528] |

|[36.0,212465.0,13.0,0.0,0.0,40.0]   | <=50K.|[212464.99927015396,6.455148844458399,-8.458640605561254]  |

|[26.0,82091.0,9.0,0.0,0.0,39.0]     | <=50K.|[82090.999542367,2.489111409624171,-3.335593188553175]     |

|[58.0,299831.0,9.0,0.0,0.0,35.0]    | <=50K.|[299830.9989556855,9.111696151562521,-11.909141441347733]  |

|[48.0,279724.0,9.0,3103.0,0.0,48.0] | >50K. |[279724.0932834471,-3094.495799296398,-16.491321474159864] |

|[43.0,346189.0,14.0,0.0,0.0,50.0]   | >50K. |[346188.9990067698,10.522518314317386,-13.720686643182727] |

|[20.0,444554.0,10.0,0.0,0.0,25.0]   | <=50K.|[444553.9991678726,13.52288689604709,-17.47586621453762]   |

|[43.0,128354.0,9.0,0.0,0.0,30.0]    | <=50K.|[128353.99933456781,3.895809826834201,-5.163630508998832]  |

|[37.0,60548.0,9.0,0.0,0.0,20.0]     | <=50K.|[60547.99950268136,1.834388499828796,-2.482228457083787]   |

|[40.0,85019.0,16.0,0.0,0.0,45.0]    | >50K. |[85018.99937940767,2.5751267063691055,-3.4924978737087193] |

+------------------------------------+-------+-----------------------------------------------------------+

only showing top 20 rows

在主成分分析的基础上，采用逻辑斯蒂回归，或者决策树模型预测居民收入是否超过50K；对Test数据集进行验证。

训练逻辑斯蒂回归模型，并进行测试，得到预测准确率

scala> val labelIndexer = new StringIndexer().setInputCol("label").setOutputCol("indexedLabel").fit(result)

labelIndexer: org.apache.spark.ml.feature.StringIndexerModel = strIdx_6721796011c5

scala> labelIndexer.labels.foreach(println)

 <=50K

 >50K

  

val featureIndexer = new VectorIndexer().setInputCol("pcaFeatures").setOutputCol("indexedFeatures").fit(result)

scala> val featureIndexer = new VectorIndexer().setInputCol("pcaFeatures").setOutputCol("indexedFeatures").fit(result)

featureIndexer: org.apache.spark.ml.feature.VectorIndexerModel = vecIdx_7b6672933fc3

scala> println(featureIndexer.numFeatures)

3

  

 val labelConverter = new IndexToString().setInputCol("prediction").setOutputCol("predictedLabel").setLabels(labelIndexer.labels)

scala> val labelConverter = new IndexToString().setInputCol("prediction").setOutputCol("predictedLabel").setLabels(labelIndexer.labels)

labelConverter: org.apache.spark.ml.feature.IndexToString = idxToStr_d0c9321aaaa9

 val lr = new LogisticRegression().setLabelCol("indexedLabel").setFeaturesCol("indexedFeatures").setMaxIter(100)

scala> val lr = new LogisticRegression().setLabelCol("indexedLabel").setFeaturesCol("indexedFeatures").setMaxIter(100)

lr: org.apache.spark.ml.classification.LogisticRegression = logreg_06812b41b118

  

val lrPipeline = new Pipeline().setStages(Array(labelIndexer, featureIndexer, lr, labelConverter))

scala> val lrPipeline = new Pipeline().setStages(Array(labelIndexer, featureIndexer, lr, labelConverter))

lrPipeline: org.apache.spark.ml.Pipeline = pipeline_b6b87b6e8cd5

val lrPipelineModel = lrPipeline.fit(result)

scala> val lrPipelineModel = lrPipeline.fit(result)

lrPipelineModel: org.apache.spark.ml.PipelineModel = pipeline_b6b87b6e8cd5

scala> val lrModel = lrPipelineModel.stages(2).asInstanceOf[LogisticRegressionModel]

lrModel: org.apache.spark.ml.classification.LogisticRegressionModel = logreg_06812b41b118

scala> println("Coefficients: " + lrModel.coefficientMatrix+"Intercept: "+lrModel.interceptVector+"numClasses: "+lrModel.numClasses+"numFeatures: "+lrModel.numFeatures)

Coefficients: -1.9828586428133616E-7  -3.5090924715811705E-4  -8.451506276498941E-4  Intercept: [-1.4525982557843347]numClasses: 2numFeatures: 3

  

val lrPredictions = lrPipelineModel.transform(testdata)

scala> val lrPredictions = lrPipelineModel.transform(testdata)

lrPredictions: org.apache.spark.sql.DataFrame = [features: vector, label: string ... 7 more fields]

 val evaluator = new MulticlassClassificationEvaluator().setLabelCol("indexedLabel").setPredictionCol("prediction")

scala> val evaluator = new MulticlassClassificationEvaluator().setLabelCol("indexedLabel").setPredictionCol("prediction")

evaluator: org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator = mcEval_38ac5c14fa2a

val lrAccuracy = evaluator.evaluate(lrPredictions)

scala> val lrAccuracy = evaluator.evaluate(lrPredictions)

lrAccuracy: Double = 0.7764235163053484

println("Test Error = " + (1.0 - lrAccuracy))

scala> println("Test Error = " + (1.0 - lrAccuracy))

Test Error = 0.22357648369465155

利用CrossValidator确定最优的参数，包括最优主成分PCA的维数、分类器自身的参数等。

import org.apache.spark.ml.feature.PCAModel
import org.apache.spark.ml.tuning.{ParamGridBuilder,CrossValidator}

scala> import org.apache.spark.ml.feature.PCAModel

scala> import org.apache.spark.ml.tuning.{ParamGridBuilder,CrossValidator}

val pca = new PCA().setInputCol("features").setOutputCol("pcaFeatures")

scala> val pca = new PCA().setInputCol("features").setOutputCol("pcaFeatures")

pca: org.apache.spark.ml.feature.PCA = pca_b11b53a1002b

 val labelIndexer = new StringIndexer().setInputCol("label").setOutputCol("indexedLabel").fit(df)

scala> val labelIndexer = new StringIndexer().setInputCol("label").setOutputCol("indexedLabel").fit(df)

labelIndexer: org.apache.spark.ml.feature.StringIndexerModel = strIdx_f2a42d5e19c9

 val featureIndexer = new VectorIndexer().setInputCol("pcaFeatures").setOutputCol("indexedFeatures")

scala> val featureIndexer = new VectorIndexer().setInputCol("pcaFeatures").setOutputCol("indexedFeatures")

featureIndexer: org.apache.spark.ml.feature.VectorIndexer = vecIdx_0f9f0344fcfd

 val labelConverter = new IndexToString().setInputCol("prediction").setOutputCol("predictedLabel").setLabels(labelIndexer.labels)

scala> val labelConverter = new IndexToString().setInputCol("prediction").setOutputCol("predictedLabel").setLabels(labelIndexer.labels)

labelConverter: org.apache.spark.ml.feature.IndexToString = idxToStr_74967420c4ea

 val lr = new LogisticRegression().setLabelCol("indexedLabel").setFeaturesCol("indexedFeatures").setMaxIter(100)

scala> val lr = new LogisticRegression().setLabelCol("indexedLabel").setFeaturesCol("indexedFeatures").setMaxIter(100)

lr: org.apache.spark.ml.classification.LogisticRegression = logreg_3a643c15517d

val lrPipeline = new Pipeline().setStages(Array(pca, labelIndexer, featureIndexer, lr, labelConverter))

scala> val lrPipeline = new Pipeline().setStages(Array(pca, labelIndexer, featureIndexer, lr, labelConverter))

lrPipeline: org.apache.spark.ml.Pipeline = pipeline_4ff414fedeed

val paramGrid = new ParamGridBuilder().addGrid(pca.k, Array(1,2,3,4,5,6)).addGrid(lr.elasticNetParam, Array(0.2,0.8)).addGrid(lr.regParam, Array(0.01, 0.1, 0.5)).build()

scala> val paramGrid = new ParamGridBuilder().addGrid(pca.k, Array(1,2,3,4,5,6)).addGrid(lr.elasticNetParam, Array(0.2,0.8)).addGrid(lr.regParam, Array(0.01, 0.1, 0.5)).build()

paramGrid: Array[org.apache.spark.ml.param.ParamMap] =

Array({

        logreg_3a643c15517d-elasticNetParam: 0.2,

        pca_b11b53a1002b-k: 1,

        logreg_3a643c15517d-regParam: 0.01

}, {

        logreg_3a643c15517d-elasticNetParam: 0.2,

        pca_b11b53a1002b-k: 2,

        logreg_3a643c15517d-regParam: 0.01

}, {

        logreg_3a643c15517d-elasticNetParam: 0.2,

        pca_b11b53a1002b-k: 3,

        logreg_3a643c15517d-regParam: 0.01

}, {

        logreg_3a643c15517d-elasticNetParam: 0.2,

        pca_b11b53a1002b-k: 4,

        logreg_3a643c15517d-regParam: 0.01

}, {

        logreg_3a643c15517d-elasticNetParam: 0.2,

        pca_b11b53a1002b-k: 5,

        logreg_3a643c15517d-regParam: 0.01

}, {

        logreg_3a643c15517d-elasticNetParam: 0.2,

        pca_b11b53a1002b-k: 6,

        logreg_3a643c15517d-regParam: 0.01

}, {

        logreg_3a643c15517d-elasticNetParam: 0.2,

        pca_b11b53a1002...

val cv = new CrossValidator().setEstimator(lrPipeline).setEvaluator(new MulticlassClassificationEvaluator().setLabelCol("indexedLabel").setPredictionCol("prediction")).setEstimatorParamMaps(paramGrid).setNumFolds(3)

scala> val cv = new CrossValidator().setEstimator(lrPipeline).setEvaluator(new MulticlassClassificationEvaluator().setLabelCol("indexedLabel").setPredictionCol("prediction")).setEstimatorParamMaps(paramGrid).setNumFolds(3)

cv: org.apache.spark.ml.tuning.CrossValidator = cv_ae1c8fdde36b

val cvModel = cv.fit(df)

scala> val cvModel = cv.fit(df)

cvModel: org.apache.spark.ml.tuning.CrossValidatorModel = cv_ae1c8fdde36b

 val lrPredictions=cvModel.transform(test)

scala> val lrPredictions=cvModel.transform(test)

lrPredictions: org.apache.spark.sql.DataFrame = [features: vector, label: string ... 7 more fields]

val evaluator = new MulticlassClassificationEvaluator().setLabelCol("indexedLabel").setPredictionCol("prediction")

scala> val evaluator = new MulticlassClassificationEvaluator().setLabelCol("indexedLabel").setPredictionCol("prediction")

evaluator: org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator = mcEval_c6a4b78effe0

val lrAccuracy = evaluator.evaluate(lrPredictions)

scala> val lrAccuracy = evaluator.evaluate(lrPredictions)

lrAccuracy: Double = 0.7833268290041506

println("准确率为"+lrAccuracy)

scala> println("准确率为"+lrAccuracy)

准确率为0.7833268290041506

scala> val bestModel= cvModel.bestModel.asInstanceOf[PipelineModel]

bestModel: org.apache.spark.ml.PipelineModel = pipeline_4ff414fedeed

scala> val lrModel = bestModel.stages(3).asInstanceOf[LogisticRegressionModel]

lrModel: org.apache.spark.ml.classification.LogisticRegressionModel = logreg_3a643c15517d

scala> println("Coefficients: " + lrModel.coefficientMatrix + "Intercept: "+lrModel.interceptVector+ "numClasses: "+lrModel.numClasses+"numFeatures: "+lrModel.numFeatures)

Coefficients: -1.5003517160303808E-7  -1.6893365468787863E-4  ... (6 total)Intercept: [-7.459195847829245]numClasses: 2numFeatures: 6

scala> val pcaModel = bestModel.stages(0).asInstanceOf[PCAModel]

pcaModel: org.apache.spark.ml.feature.PCAModel = pca_b11b53a1002b

 println("Primary Component: " + pcaModel.pc)

scala> println("Primary Component: " + pcaModel.pc)

Primary Component: -9.905077142269292E-6   -1.435140700776355E-4   ... (6 total)

0.9999999987209459      3.0433787125958012E-5   ...

-1.0528384042028638E-6  -4.2722845240104086E-5  ...

3.036788110999389E-5    -0.9999984834627625     ...

-3.9138987702868906E-5  0.0017298954619051868   ...

-2.1955537150508903E-6  -1.3109584368381985E-4  ...

可以看出，PCA最优的维数是6。

5 实验总结

zbxmc
关注
  • 22
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
Spark MLlib机器学习库原理与代码实例讲解
禅与计算机程序设计艺术
06-07 439
Spark MLlib机器学习库原理与代码实例讲解 1.背景介绍 1.1 大数据时代的机器学习需求 在当今大数据时代,海量数据的产生和积累为机器学习的发展提供了前所未有的机遇。传统的机器学习算法和框架在处理大规模数
【Spark】实验6 Spark机器学习库MLlib编程实践
Lenhart001的博客
06-05 5423
2、构建聚类模型可以采用Kmeans及GMM，并训练。4、查看聚类中心或混合成分参数，分析并对比聚类效果。i.即聚类的各类别是否反应其真实所属。【 救救孩子，不会做 π _ π 】3.训练分类模型并预测居民收入。2.进行主成分分析（PCA）
机器学习实践：Spark MLlib库介绍与使用-3
奔腾游子
01-07 5513
机器学习实践：Spark MLlib库介绍与使用 1、实验描述 MLlib （ Machine Learning Library ）是 Spark 的一个机器学习库。它能够较容易地解决一些实际的大规模机器学习问题。本实验旨在学习 Spark 的机器学习库—— MLlib 的相关知识，了解 MLlib 与 ML 之间的区别和联系，掌握 MLlib 中的几个基本数据类型 实验时长：90分钟 主要步骤： 学习Mllib的基本数据类型 学习Mllib的基本算法库 利用Mllib算法库中的协同
基于Spark的机器学习实践 (二) - 初识MLlib
JavaEdge全是干货的技术号
04-09 2164
1 MLlib概述 1.1 MLlib 介绍 ◆ 是基于Spark core的机器学习库,具有Spark的优点 ◆ 底层计算经过优化,比常规编码效率往往要高 ◆ 实现了多种机器学习算法,可以进行模型训练及预测 1.2 Spark MLlib实现的算法 ◆ 逻辑回归 朴素贝叶斯 线性回归 SVM 决策树 LDA 矩阵分解 1.3 Spark MLlib官方介绍 1.3.1 搜索官方文档 1.3...
spark编程基础python版实验报告_Spark编程基础（Python版）
weixin_39849239的博客
12-11 2320
章 大数据技术概述1.1 大数据概念与关键技术1.1.1 大数据的概念1.1.2 大数据关键技术1.2 代表性大数据技术1.2.1 Hadoop1.2.2 Spark1.2.3 Flink1.2.4 Beam1.3 编程语言的选择1.4 在线资源1.5 本章小结1.6 习题实验1 Linux系统的安装和常用命令第2章 Spark的设计与运行原理章 大数据技术概述1.1 大数据概念与关键技术1.1....
在实践中学习Spark计算框架（00）
X10的博客
11-23 945
Spark编程基础：00.初步了解 参考书籍：厦门大学-林子雨-Spark编程基础 ———————————————————— 先修课程：（当前状况：了解） 1.大数据技术导论：《大数据技术原理与应用》 2.数据库系统原理：（了解关系数据库与SQL语句） 3.编程能力：（了解面向对象编程基础知识，如Java、C++） ———————————————————— 《Spark编程基础》简介： 以 Scala 作为开发 Spark 应用程序的编程语言。 全书共 8 章： 1.大数据技术概述 2.Scala语
Spark入门实战系列--8.Spark MLlib（下）--机器学习库SparkMLlib实战
FlashCloud
05-14 644
1、MLlib实例 1.1 聚类实例 1.1.1 算法说明 聚类（Cluster analysis）有时也被翻译为簇类，其核心任务是：将一组目标object划分为若干个簇，每个簇之间的object尽可能相似，簇与簇之间的object尽可能相异。聚类算法是机器学习（或者说是数据挖掘更合适）中重要的一部分，除了最为简单的K-Means聚类算法外，比较常见的还有层次法（CURE、CHAMELEON
实验七：Spark初级编程实践
qq_36428822的博客
06-28 1672
由于CSDN上传md文件总是会使图片失效 完整的实验文档地址如下： https://download.csdn.net/download/qq_36428822/85814468设备名称 LAPTOP-9KJS8HO6 处理器 Intel® Core™ i5-10300H CPU @ 2.50GHz 2.50 GHz 机带 RAM 16.0 GB (15.8 GB 可用) 主机操作系统 Windows 10 家庭中文版 虚拟机操作系统 ubuntukylin-16.04 Hadoop 版本 3.1.3
《Spark MLlib 机器学习实战》1——读后总结
xingoo
06-14 150
《Spark MLlib 机器学习实战》1——读后总结 1 概念 2 安装 3 RDD RDD包含两种基本的类型：Transformation和Action。RDD的执行是延迟执行，只有Action算子才会触发任务的执行。 宽依赖和窄依赖用于切分任务，如果都是窄依赖，那么就可以最大化的利用并行。 常用操作： cache 缓存 cartesia...
《Spark编程基础及项目实践》课后习题及答案7.pdf
04-04
《Spark编程基础及项目实践》课程的课后习题涵盖了Spark图形处理的基础概念和技术，主要涉及图论基础知识、Spark图计算API以及实际操作题目。以下是这些知识点的详细说明： 1. **图论基础**： - **度的概念**：在...
《Spark编程基础及项目实践》试卷及答案2套.pdf
04-04
【Spark编程基础及项目实践】试卷涉及的知识点涵盖了Spark的核心概念、大数据处理、Scala语言基础以及Spark的部署和运行模式。以下是对这些知识点的详细解释： 1. **大数据的特征**：大数据通常具有Volume（大量）...
工信部Spark初级考前辅导.pdf
05-23
4. **MLlib**：机器学习库，包含多种算法和工具。 5. **GraphX**：图处理框架，适用于图分析任务。 【Spark端口】 在Spark集群中，常见的端口有： - 8080：Spark Web UI，用于监控集群状态。 - 4040：Spark Job监控...
RDD编程初级实践Tom,DataBase,80 Tom,Algorithm,50 Tom,DataStructure,60 Jim,DataBas
06-09
此外，Spark MLlib库提供了许多机器学习算法，如线性回归、逻辑回归、支持向量机等，这些都可以基于RDD进行训练和预测。 再来看"Tom,DataStructure,60"，可能意味着Tom在数据结构方面的得分是60。在Spark中，RDD是...
基于spark的电影点评系统
04-08
Spark的核心组件包括Spark Core、Spark SQL、Spark Streaming、MLlib（机器学习库）和GraphX，这些组件相互协作，可以支持批处理、交互式查询、实时流处理和图形计算等多种应用场景。 在这个电影点评系统中，Spark ...
Spark学习
最新发布
weixin_46935426的博客
07-24 1000
系统的学习spark
Spark实时（三）：Structured Streaming入门案例
Lansonli（蓝深李）的博客
07-24 706
我们使用Structured Streaming来监控socket数据统计WordCount。
数据开发/数仓工程师上手指南(一)数仓概念总览
master_hunter的博客
07-24 1658
数据库设计用于支持日常业务操作和事务处理。数据结构高度规范化，注重数据的一致性和实时性。优化事务处理性能，处理频繁的读写操作。数据仓库设计用于支持数据分析和决策支持系统。数据结构非规范化，存储大量的历史数据。优化查询性能，支持复杂的多维分析和大规模数据处理。数据库(Database)数据仓库(Data Warehouse)面向事务分析数据类型细节、业务综合、清洗过的数据数据特点当前的、最新的历史的、跨时间维护目的日常操作长期信息需求、决策支持设计模型。
spark机器学习库mllib编程实践
06-28
### 回答1： Spark机器学习库MLlib是一个基于Spark平台的分布式机器学习库，它提供了一系列常用的机器学习算法和工具，包括分类、回归、聚类、协同过滤、降维等。使用MLlib可以方便地进行大规模的机器学习任务，同时也支持在线学习和增量学习等高级功能。在编程实践中，我们可以使用MLlib来构建机器学习模型，对数据进行预处理和特征工程，进行模型训练和评估等。同时，MLlib还支持与其他Spark组件的无缝集成，如Spark SQL、Spark Streaming等，可以实现更加复杂的机器学习应用场景。 ### 回答2： Spark机器学习库MLlib是一个强大的分布式机器学习框架，原生支持Spark的分布式计算，可以处理大规模的数据集，并提供一系列常见的机器学习算法和工具，包括分类、回归、聚类、推荐等。 MLlib的编程实践主要分为以下几个步骤： 1. 数据预处理 在使用MLlib进行机器学习之前，需要对数据进行预处理，清洗和准备工作，如数据清洗、缺失值填充、特征选择、特征缩放等。MLlib对数据的处理和转换有良好的支持，可以使用Spark的数据处理和转换函数以及MLlib的特征处理函数进行数据的预处理。 2. 特征工程 特征工程是机器学习过程中非常重要的一步，它可以帮助我们选择和构建合适的特征，减少噪声数据对模型的影响。MLlib提供了一系列特征处理函数，如特征标准化、特征编码、特征提取等，可以帮助用户方便地进行特征工程的实践。 3. 模型训练 MLlib支持多种机器学习算法，包括分类、回归、聚类和推荐系统等，用户可以选择合适的算法对数据进行建模和训练。在模型训练过程中，需要进行参数选择和调优，可以通过交叉验证等方法选择最佳的模型和参数。 4. 模型评估和选择 在训练和调优完成后，需要对训练好的模型进行评估和选择。MLlib提供了多种模型评估指标和方法，如准确率、召回率、F1值等，可以帮助用户选择最佳的模型和参数。 5. 预测和应用 在训练和评估好模型之后，就可以使用训练好的模型进行预测和应用了。MLlib提供了预测函数和模型保存与加载功能，可以帮助用户方便地进行模型应用。 总之，MLlib提供了一系列丰富的机器学习算法和工具，并且能够处理大规模数据集，有着非常广泛的应用场景。对于需要对海量数据进行机器学习的用户来说，MLlib的编程实践是非常重要的，需要深入理解其算法和实现方法，以便更好地应用到实际场景中。 ### 回答3： Spark机器学习库MLlib是一个开源的大数据机器学习库，它提供了一套强大的分布式机器学习工具，可以让我们在Spark中轻松地进行机器学习任务。 MLlib提供了许多常见的机器学习算法和工具，包括分类、回归、聚类、降维等，同时也支持常用的数据格式和数据预处理功能。同时，它还提供了很多便利的函数和工具，使得我们可以很方便地处理大规模数据集。 在进行MLlib编程实践时，我们需要掌握以下几个方面的知识： 1. 数据准备与处理：在进行机器学习任务之前，我们需要对数据进行预处理和准备。这包括数据清洗、特征提取、特征缩放、数据转化等，MLlib提供了许多工具和函数来帮助我们完成这些任务。 2. 算法选择与调优：根据我们的任务需求和数据特征，我们需要选择合适的机器学习算法，MLlib提供了常见的分类、回归、聚类、降维算法，我们需要根据具体情况进行选择和调优。 3. 模型训练和预测：在算法选择和调优完成后，我们需要对数据集进行模型训练和预测。这包括模型的拟合、评估、优化等。MLlib提供了很多训练和评估模型的函数和工具。 4. 分布式计算：MLlib是在分布式环境下运行的，因此我们需要掌握Spark集群的搭建和优化，以充分利用分布式计算的优势，提高计算效率和速度。 在进行MLlib编程实践时，我们需要先熟悉Spark的基本操作和RDD编程模型，然后进一步学习MLlib库的API和使用规则。同时，我们还需要深入了解机器学习算法和常见的数据处理和挖掘技术，以便对数据进行准备和处理。 总之，通过使用Spark机器学习库MLlib，我们可以快速地进行大规模数据集的机器学习任务，从而获得更多的洞见和价值。通过MLlib编程实践，我们可以提高自己的机器学习和大数据处理能力，从而更好地应对现代数据科学的挑战。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zbxmc

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值