精华内容
下载资源
问答
  • MLlib

    2017-07-28 10:59:02
    1、归一化from pyspark.mllib.feature import Normalizer normlizer = Normalizer() vector = sc.parallelize([x]) normalized_x_mllib = normlizer.transform(vector).first().toArray()

    1、归一化

    from pyspark.mllib.feature import Normalizer
    normlizer = Normalizer()
    vector = sc.parallelize([x])
    normalized_x_mllib = normlizer.transform(vector).first().toArray()
    
    展开全文
  • Spark MLlib简介

    2021-01-07 03:36:16
    MLlib 是 Spark 的机器学习库,旨在简化机器学习的工程实践工作,并方便扩展到更大规模。 MLlib 由一些通用的学习算法和工具组成,包括分类、回归、聚类、协同过滤、降维等,同时还包括底层的优化原语和高层的管道 ...
  • Spark MLlib

    2019-12-18 09:22:15
    Spark MLlib一、Spark MLlib模型选择与调参CrossValidatorTrainValidationSplit 部分内容原文地址: 掘金:美图数据团队:从Spark MLlib到美图机器学习框架实践 一、Spark MLlib 在 Spark 官网上展示了逻辑回归...



    部分内容原文地址:
    掘金:美图数据团队:从Spark MLlib到美图机器学习框架实践
    博客园:牧梦者:Spark MLlib 机器学习 ***



    一、Spark MLlib

    在 Spark 官网上展示了逻辑回归算法在 Spark 和 Hadoop 上运行性能比较,从下图可以看出 MLlib 比 MapReduce 快了 100 倍。
    在这里插入图片描述
    Spark MLlib 主要包括以下几方面的内容:

    • 学习算法:分类、回归、聚类和协同过滤;
    • 特征处理:特征提取、变换、降维和选择;
    • 管道(Pipeline):用于构建、评估和调整机器学习管道的工具;
    • 持久性:保存和加载算法,模型和管道;
    • 实用工具:线性代数,统计,最优化,调参等工具。

    Spark MLlib 典型流程如下:

    • 构造训练数据集
    • 构建各个 Stage
    • Stage 组成 Pipeline
    • 启动模型训练
    • 评估模型效果
    • 计算预测结果

    通过一个 Pipeline 的文本分类示例来加深理解:

    import org.apache.spark.ml.{Pipeline, PipelineModel}
    import org.apache.spark.ml.classification.LogisticRegression
    import org.apache.spark.ml.feature.{HashingTF, Tokenizer}
    import org.apache.spark.ml.linalg.Vector
    import org.apache.spark.sql.Row
    
    // Prepare training documents from a list of (id, text, label) tuples.
    val training = spark.createDataFrame(Seq(
     (0L, "a b c d e spark", 1.0),
     (1L, "b d", 0.0),
     (2L, "spark f g h", 1.0),
     (3L, "hadoop mapreduce", 0.0)
    )).toDF("id", "text", "label")
    
    // Configure an ML pipeline, which consists of three stages: tokenizer, hashingTF, and lr.
    val tokenizer = new Tokenizer()
     .setInputCol("text")
     .setOutputCol("words")
    val hashingTF = new HashingTF()
     .setNumFeatures(1000)
     .setInputCol(tokenizer.getOutputCol)
     .setOutputCol("features")
    val lr = new LogisticRegression()
     .setMaxIter(10)
     .setRegParam(0.001)
    val pipeline = new Pipeline()
     .setStages(Array(tokenizer, hashingTF, lr))
    
    // Fit the pipeline to training documents.
    val model = pipeline.fit(training)
    
    // Now we can optionally save the fitted pipeline to disk
    model.write.overwrite().save("/tmp/spark-logistic-regression-model")
    
    // We can also save this unfit pipeline to disk
    pipeline.write.overwrite().save("/tmp/unfit-lr-model")
    
    // And load it back in during production
    val sameModel = PipelineModel.load("/tmp/spark-logistic-regression-model")
    
    // Prepare test documents, which are unlabeled (id, text) tuples.
    val test = spark.createDataFrame(Seq(
     (4L, "spark i j k"),
     (5L, "l m n"),
     (6L, "spark hadoop spark"),
     (7L, "apache hadoop")
    )).toDF("id", "text")
    
    // Make predictions on test documents.
    model.transform(test)
     .select("id", "text", "probability", "prediction")
     .collect()
     .foreach { case Row(id: Long, text: String, prob: Vector, prediction: Double) =>
       println(s"($id, $text) --> prob=$prob, prediction=$prediction")
     }
    

    模型选择与调参

    Spark MLlib 提供了 CrossValidator 和 TrainValidationSplit 两个模型选择和调参工具。模型选择与调参的三个基本组件分别是 Estimator、ParamGrid 和 Evaluator,其中 Estimator 包括算法或者 Pipeline;ParamGrid 即 ParamMap 集合,提供参数搜索空间;Evaluator 即评价指标。

    CrossValidator

    CrossValidator 将数据集按照交叉验证数切分成 n 份,每次用 n-1 份作为训练集,剩余的作为测试集,训练并评估模型,重复 n 次,得到 n 个评估结果,求 n 次的平均值作为这次交叉验证的结果。接着对每个候选 ParamMap 重复上面的过程,选择最优的 ParamMap 并重新训练模型,得到最优参数的模型输出。

    // We use a ParamGridBuilder to construct a grid of parameters to search over.
    // With 3 values for hashingTF.numFeatures and 2 values for lr.regParam,
    // this grid will have 3 x 2 = 6 parameter settings for CrossValidator to choose from.
    val paramGrid = new ParamGridBuilder()
     .addGrid(hashingTF.numFeatures, Array(10, 100, 1000))
     .addGrid(lr.regParam, Array(0.1, 0.01))
     .build()
    
    // We now treat the Pipeline as an Estimator, wrapping it in a CrossValidator instance.
    // This will allow us to jointly choose parameters for all Pipeline stages.
    // A CrossValidator requires an Estimator, a set of Estimator ParamMaps, and an Evaluator.
    // Note that the evaluator here is a BinaryClassificationEvaluator and its default metric
    // is areaUnderROC.
    val cv = new CrossValidator()
     .setEstimator(pipeline)
     .setEvaluator(new BinaryClassificationEvaluator)
     .setEstimatorParamMaps(paramGrid)
     .setNumFolds(2)  // Use 3+ in practice
     .setParallelism(2)  // Evaluate up to 2 parameter settings in parallel
    
    // Run cross-validation, and choose the best set of parameters.
    val cvModel = cv.fit(training)
    
    // Prepare test documents, which are unlabeled (id, text) tuples.
    val test = spark.createDataFrame(Seq(
     (4L, "spark i j k"),
     (5L, "l m n"),
     (6L, "mapreduce spark"),
     (7L, "apache hadoop")
    )).toDF("id", "text")
    
    // Make predictions on test documents. cvModel uses the best model found (lrModel).
    cvModel.transform(test)
     .select("id", "text", "probability", "prediction")
     .collect()
     .foreach { case Row(id: Long, text: String, prob: Vector, prediction: Double) =>
       println(s"($id, $text) --> prob=$prob, prediction=$prediction")
     }
    

    TrainValidationSplit

    TrainValidationSplit 使用 trainRatio 参数将训练集按照比例切分成训练和验证集,其中 trainRatio 比例的样本用于训练,剩余样本用于验证。与 CrossValidator 不同的是,TrainValidationSplit 只有一次验证过程,可以简单看成是 CrossValidator 的 n 为 2 时的特殊版本。

    import org.apache.spark.ml.evaluation.RegressionEvaluator
    import org.apache.spark.ml.regression.LinearRegression
    import org.apache.spark.ml.tuning.{ParamGridBuilder, TrainValidationSplit}
    
    // Prepare training and test data.
    val data = spark.read.format("libsvm").load("data/mllib/sample_linear_regression_data.txt")
    val Array(training, test) = data.randomSplit(Array(0.9, 0.1), seed = 12345)
    
    val lr = new LinearRegression()
       .setMaxIter(10)
    
    // We use a ParamGridBuilder to construct a grid of parameters to search over.
    // TrainValidationSplit will try all combinations of values and determine best model using
    // the evaluator.
    val paramGrid = new ParamGridBuilder()
     .addGrid(lr.regParam, Array(0.1, 0.01))
     .addGrid(lr.fitIntercept)
     .addGrid(lr.elasticNetParam, Array(0.0, 0.5, 1.0))
     .build()
    
    // In this case the estimator is simply the linear regression.
    // A TrainValidationSplit requires an Estimator, a set of Estimator ParamMaps, and an Evaluator.
    val trainValidationSplit = new TrainValidationSplit()
     .setEstimator(lr)
     .setEvaluator(new RegressionEvaluator)
     .setEstimatorParamMaps(paramGrid)
     // 80% of the data will be used for training and the remaining 20% for validation.
     .setTrainRatio(0.8)
     // Evaluate up to 2 parameter settings in parallel
     .setParallelism(2)
    
    // Run train validation split, and choose the best set of parameters.
    val model = trainValidationSplit.fit(training)
    
    // Make predictions on test data. model is the model with combination of parameters
    // that performed best.
    model.transform(test)
     .select("features", "label", "prediction")
     .show()
    

    MLlib目录结构

    在这里插入图片描述

    MLlib处理流程

    在这里插入图片描述

    MLlib构成

    两个算法包:

    • spark.mllib:包含原始API,构建在RDD之上。
    • spark.ml:基于DataFrame构建的高级API。

    spark.ml具备更优的性能和更好的扩展性,建议优先选用。
    spark.mllib相较于spark.ml包含更多的算法。

    数据类型(Data Type)

    向量:带类别的向量,矩阵等。

    数学统计计算库

    基本统计量(min,max,average等),相关分析,随机数产生器,假设检验等。

    机器学习管道(pipeline)

    Transformer、Estimator、Parameter。

    机器学习算法

    分类算法、回归算法、聚类算法、协同过滤。

    二、Spark MLlib算法库

    Spark MLlib算法库主要包含两类算法:分类算法与回归算法。

    2.1 推荐算法(AlterNating Least Squares)(ALS)

    协同过滤(Collaborative Filtering,简称CF)推荐算法,CF的基本思想是根据用户之前的喜好以及其他兴趣相近的用户的选择来给用户推荐物品。

    CF推荐算法分类:

    • User-based:基于用户对物品的偏好找到相邻邻居用户,然后将邻居用户喜好的推荐给当前用户。
    • Item-based:基于用户对物品的偏好找到相似的物品,然后根据用户的历史偏好,推荐相似的物品给他。

    2.2 ALS:Scala

    import org.apache.spark.ml.evalution.RegressionEvaluator
    import org.apache.soark.ml.recommendation.ALS
    
    case class Rating(userId:Int,movieId:Int,rating:Float,timestamp:Long)
    
    def parseRating(str: String): Rating = {
    	val fields = str.split("::")
    	assert(fields.size == 4)
    	Rating(fields(0).toInt,fields(1).toInt,fields(2).toFloat,fields(3).toLong)
    }
    
    val ratings = spark.read.textFile("data/mllib/als/sample_movicelens_ratings.txt")
    	.map(parseRating)
    	,toDF()
    
    val Array(training.test) = ratings.randomSplit(Array(0.8,0.2))
    
    val als = new ALS()
    	.setMaxIter(5)
    	.setRegParam(0.01)
    	.setUserCol("userId")
    	.setItemCOl("movieId")
    	.setRatingCol("rating")
    
    val model = als.fit(training)
    
    val predictions = model.transform(test)
    
    val evaluator = new RegressionEvaluator()
    	.setMetricName("rmse")
    	.setLabelCol("rating")
    	.setPredicationCol("prediction")
    
    val rmse = evaluator.evaluate(predictions)
    
    println(s"Root-mean-squar error = $rmse")
    
    展开全文
  • mllib-utils 与Spark的MLLib一起工作的美好之处。
  • 探索 MLlib 博客文章的源代码
  • mllib-grid-search 在 MLlib 中进行网格搜索的示例项目
  • spark-mllib

    2016-05-03 14:40:45
    翻译spark mllib的相关官网资料,便于阅读,有些不准确的地方,为阅读提供方便。
  • sparkmllib机器学习源码

    2018-11-01 06:57:33
    sparkmllib机器学习.
  • Mllib学习

    2018-06-15 16:58:51
    http://spark.apache.org/docs/latest/mllib-data-types.html 这里有很多例子1、vector基础用法:import org.apache.spark.mllib.linalg.Vectors object Test { def main(args: Array[String]) { val vd = ...

    1、基础用法:

    http://spark.apache.org/docs/latest/mllib-data-types.html 这里有很多例子

    1、vector

    import org.apache.spark.mllib.linalg.Vectors  
      
    object Test {  
      def main(args: Array[String]) {  
        val vd = Vectors.dense(2, 5, 8)  
        println(vd(1))  
        println(vd)  
      
        //向量个数,序号,value  
        val vs = Vectors.sparse(4, Array(0, 1, 2, 3), Array(9, 3, 5, 7))  //表示向量长度为4,序号为0123,对应值为9357
        println(vs(0)) //序号访问  
        println(vs)   
    }  
    Vectors.sparse(4, Seq((0, 1.0), (3, -2.0))) //表示向量长度为4,在0位置为1,在3位置为-2

    2、matrix.sparse的api理解:

    https://blog.csdn.net/sinat_29508201/article/details/54089771

    其中colPtrs的参数意义是最后值的向量中,到第几个位置下一个新列的元素就开始了,这里到index 为 2 的时候,index为1的列的元素就开始出现,到index为3的时候,index为2的列的元素开始出现,这个参数的最后一维为所有非0元素的个数。


    2、应用例子,矩阵求逆:

    原始代码参考:https://blog.csdn.net/u011707542/article/details/53543739

    val mt1 = sc.parallelize(List("2,0,0","0,1,0","0,0,1")).map(r=>(r.split(",").map(_.toDouble))).map(r=>Vectors.dense(r))
    val rowMatrix2=new RowMatrix(mt1)
    val nCoef = rowMatrix2.numCols.toInt
    val svd2 = rowMatrix2.computeSVD(nCoef, computeU = true)
    val invS = DenseMatrix.diag(new DenseVector(svd2.s.toArray.map(x => math.pow(x,-1))))
    val U = new DenseMatrix(svd2.U.numRows().toInt,svd2.U.numCols().toInt,svd2.U.rows.collect.flatMap(x => x.toArray))
    val V = svd2.V
    (V.multiply(invS2)).multiply(U)

    感觉用起来不灵活,因为rdd里面不能嵌套rdd。找到java里面有个包叫jama,处理矩阵类的问题

    https://blog.csdn.net/shubingzhuoxue/article/details/50770979 jamaapi的介绍

    在spark-shell里面试验的时候,可以从官网下载jar包,然后

    spark-shell --jars ~/sourcefiles/jar/Jama-1.0.3.jar 把这个包添加进引用,试验;

    一个写了矩阵api的网页:https://blog.csdn.net/Shadow_Mi/article/details/51822472?locationNum=2

    jama网页:https://math.nist.gov/javanumerics/jama/doc/

    初始化一个矩阵:

    val a  = Array(Array(1.0, 0.0, 0.0), Array(0.0, 1.0, 0.0), Array(0.0, 0.0, 1.0)) //(每一个Array元素是一个行向量)

    val am = new Matrix(a)

    am.get(0,0) //取得位置0,0的元素

    res11: Double = 1.0


    但是jama库感觉会自动截断,把double截断到只剩小数点后三位,实践计算误差太大,。。。不适合用

    转向scala的数值计算库:breeze 文档及代码:https://github.com/scalanlp/breeze/wiki/Linear-Algebra-Cheat-Sheet

     val a = DenseMatrix((0.861,0.135,0.003),(0.638,0.360,0.003),(0.638,0.360,0.003)) //new一个矩阵



    展开全文
  • Spark MLLib

    千次阅读 2016-10-12 16:27:35
    MLLib是Spark的机器学习库。 MLLib提供了两个包:spark.mlib是建立在rdd的原生api;spark.ml是建立在DataFrame上更高层api,主要用于机器学习的pipeline操作。 推荐使用spark.ml,因为DataFrame具有多样性以及...

    MLLib是Spark的机器学习库。


    MLLib提供了两个包:spark.mlib是建立在rdd的原生api;spark.ml是建立在DataFrame上更高层api,主要用于机器学习的pipeline操作。


    推荐使用spark.ml,因为DataFrame具有多样性以及操作柔性。 但Spark会继续支持spark.mllib,spark.mllib将会开发更多的新特性和算法。如果开发者熟悉ML pipline,那就优先对spark.ml开发新算法。(大概的思路是,这两个都重要。底层会持续开发spark.mllib,应用层要用spark.ml。)


    MLLib的线性代数包breeze,这个包依赖于netlib-java。


    关于spark.ml包

        pipeLine涉及到的主要概念:

            DataFrame:它负责存储数据,也能对数据做各种操作。

            Transformer: 把一种dataframe转换到另一种dataframe。

            Estimator: 它是一个算法,算法对dataframe进行处理,然后产生一个transformer。一个学习算法就是一个Estimator。

            pipeline: 多个transformer和多个estimator组合成一个有序的工作流,执行一个完整的机器学习流程。

            paramter:所有transformer和estimator共享了一个共用接口以指定参数。


        如何工作

            一个pipeline是一系列的stage,每一个stage或者是一个tranformer或者是一个estimator。这些statge是有序的。一个dataFrame从input进去,一个一个stage走过,形成最后结果。对于transformer stage来说,在dataframe上使用一个transform()函数,对estimator来说,它对dataframe使用fit()函数。

            从广义上说,一个pipeline是一个estimator,有fit函数。


        第一个例子:

    package my.demo;
    
    import java.util.Arrays;
    import java.util.List;
    
    import org.apache.spark.SparkConf;
    import org.apache.spark.api.java.JavaSparkContext;
    import org.apache.spark.ml.classification.LogisticRegressionModel;
    import org.apache.spark.ml.param.ParamMap;
    import org.apache.spark.ml.classification.LogisticRegression;
    import org.apache.spark.mllib.linalg.Vectors;
    import org.apache.spark.mllib.regression.LabeledPoint;
    import org.apache.spark.sql.DataFrame;
    import org.apache.spark.sql.Row;
    import org.apache.spark.sql.SQLContext;
    
    public class SparkML1 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		SparkConf conf = new SparkConf().setAppName("SparkSQLDemo");
    		conf.setMaster("local[2]");
    		JavaSparkContext jsc = new JavaSparkContext(conf);
    		SQLContext sqlContext = new org.apache.spark.sql.SQLContext(jsc);
    
    		DataFrame training = sqlContext.createDataFrame(Arrays.asList(
    				new LabeledPoint(1.0, Vectors.dense(0.0, 1.1, 0.1)),
    				new LabeledPoint(0.0, Vectors.dense(2.0, 1.0, -1.0)),
    				new LabeledPoint(0.0, Vectors.dense(2.0, 1.3, 1.0)),
    				new LabeledPoint(1.0, Vectors.dense(0.0, 1.2, -0.5))),
    				LabeledPoint.class);
    
    		// Create a LogisticRegression instance. This instance is an Estimator.
    		LogisticRegression lr = new LogisticRegression();
    		// Print out the parameters, documentation, and any default values.
    		System.out.println("LogisticRegression parameters:\n"
    				+ lr.explainParams() + "\n");
    
    		// We may set parameters using setter methods.
    		lr.setMaxIter(10).setRegParam(0.01);
    
    		// Learn a LogisticRegression model. This uses the parameters stored in
    		// lr.
    		LogisticRegressionModel model1 = lr.fit(training);
    		// Since model1 is a Model (i.e., a Transformer produced by an
    		// Estimator),
    		// we can view the parameters it used during fit().
    		// This prints the parameter (name: value) pairs, where names are unique
    		// IDs for this
    		// LogisticRegression instance.
    		System.out.println("Model 1 was fit using parameters: "
    				+ model1.parent().extractParamMap());
    
    		// We may alternatively specify parameters using a ParamMap.
    		ParamMap paramMap = new ParamMap().put(lr.maxIter().w(20)) // Specify 1
    																	// Param.
    				.put(lr.maxIter(), 30) // This overwrites the original maxIter.
    				.put(lr.regParam().w(0.1), lr.threshold().w(0.55)); // Specify
    																	// multiple
    																	// Params.
    
    		// One can also combine ParamMaps.
    		ParamMap paramMap2 = new ParamMap().put(lr.probabilityCol().w(
    				"myProbability")); // Change output column name
    		ParamMap paramMapCombined = paramMap.$plus$plus(paramMap2);
    
    		// Now learn a new model using the paramMapCombined parameters.
    		// paramMapCombined overrides all parameters set earlier via lr.set*
    		// methods.
    		LogisticRegressionModel model2 = lr.fit(training, paramMapCombined);
    		System.out.println("Model 2 was fit using parameters: "
    				+ model2.parent().extractParamMap());
    
    		// Prepare test documents.
    		DataFrame test = sqlContext.createDataFrame(Arrays.asList(
    				new LabeledPoint(1.0, Vectors.dense(-1.0, 1.5, 1.3)),
    				new LabeledPoint(0.0, Vectors.dense(3.0, 2.0, -0.1)),
    				new LabeledPoint(1.0, Vectors.dense(0.0, 2.2, -1.5))),
    				LabeledPoint.class);
    
    		// Make predictions on test documents using the Transformer.transform()
    		// method.
    		// LogisticRegression.transform will only use the 'features' column.
    		// Note that model2.transform() outputs a 'myProbability' column instead
    		// of the usual
    		// 'probability' column since we renamed the lr.probabilityCol parameter
    		// previously.
    		DataFrame results = model2.transform(test);
    		for (Row r : results.select("features", "label", "myProbability",
    				"prediction").collect()) {
    			System.out.println("(" + r.get(0) + ", " + r.get(1) + ") -> prob="
    					+ r.get(2) + ", prediction=" + r.get(3));
    		}
    
    	}
    
    }
    


            第二个例子,关于pipeline

    package my.demo;
    
    import java.io.Serializable;
    import java.util.Arrays;
    
    import org.apache.spark.SparkConf;
    import org.apache.spark.api.java.JavaSparkContext;
    import org.apache.spark.ml.Pipeline;
    import org.apache.spark.ml.PipelineModel;
    import org.apache.spark.ml.PipelineStage;
    import org.apache.spark.ml.classification.LogisticRegression;
    import org.apache.spark.ml.feature.HashingTF;
    import org.apache.spark.ml.feature.Tokenizer;
    import org.apache.spark.sql.DataFrame;
    import org.apache.spark.sql.Row;
    import org.apache.spark.sql.SQLContext;
    public class SparkML2 {
    	
    	static public class Document implements Serializable {
    		  private long id;
    		  private String text;
    
    		  public Document(long id, String text) {
    		    this.id = id;
    		    this.text = text;
    		  }
    
    		  public long getId() { return this.id; }
    		  public void setId(long id) { this.id = id; }
    
    		  public String getText() { return this.text; }
    		  public void setText(String text) { this.text = text; }
    		}
    
    		static public class LabeledDocument extends Document implements Serializable {
    		  private double label;
    
    		  public LabeledDocument(long id, String text, double label) {
    		    super(id, text);
    		    this.label = label;
    		  }
    
    		  public double getLabel() { return this.label; }
    		  public void setLabel(double label) { this.label = label; }
    		}
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		SparkConf conf = new SparkConf().setAppName("SparkSQLDemo");
    		conf.setMaster("local[2]");
    		JavaSparkContext jsc = new JavaSparkContext(conf);
    		SQLContext sqlContext = new org.apache.spark.sql.SQLContext(jsc);
    
    			// Prepare training documents, which are labeled.
    			DataFrame training = sqlContext.createDataFrame(Arrays.asList(
    			  new LabeledDocument(0L, "a b c d e spark", 1.0),
    			  new LabeledDocument(1L, "b d", 0.0),
    			  new LabeledDocument(2L, "spark f g h", 1.0),
    			  new LabeledDocument(3L, "hadoop mapreduce", 0.0)
    			), LabeledDocument.class);
    
    			// Configure an ML pipeline, which consists of three stages: tokenizer, hashingTF, and lr.
    			Tokenizer tokenizer = new Tokenizer()
    			  .setInputCol("text")
    			  .setOutputCol("words");
    			HashingTF hashingTF = new HashingTF()
    			  .setNumFeatures(1000)
    			  .setInputCol(tokenizer.getOutputCol())
    			  .setOutputCol("features");
    			LogisticRegression lr = new LogisticRegression()
    			  .setMaxIter(10)
    			  .setRegParam(0.01);
    			Pipeline pipeline = new Pipeline()
    			  .setStages(new PipelineStage[] {tokenizer, hashingTF, lr});
    
    			// Fit the pipeline to training documents.
    			PipelineModel model = pipeline.fit(training);
    
    			// Prepare test documents, which are unlabeled.
    			DataFrame test = sqlContext.createDataFrame(Arrays.asList(
    			  new Document(4L, "spark i j k"),
    			  new Document(5L, "l m n"),
    			  new Document(6L, "mapreduce spark"),
    			  new Document(7L, "apache hadoop")
    			), Document.class);
    
    			// Make predictions on test documents.
    			DataFrame predictions = model.transform(test);
    			for (Row r: predictions.select("id", "text", "probability", "prediction").collect()) {
    			  System.out.println("(" + r.get(0) + ", " + r.get(1) + ") --> prob=" + r.get(2)
    			      + ", prediction=" + r.get(3));
    			}
    
    	}
    
    }
    


        关于Spark.mllib库

    MLLib支持local vector局部向量,和local matrics局部矩阵,它们存储在一个集群节点上,而不是像rdd分成若干块存储在不同的节点上。

    对于分类和回归问题来说,一个训练样本,在mllib里表示成"labeled point",就是有标记的点。


    local vector有两种,一种是密集vector,一种是稀疏vector。这一块存储跟matlab是一样的。






    展开全文
  • Spark MLlib应用

    2021-01-14 20:49:19
    Spark MLlib应用 实验目的 深入理解和掌握Spark MLlib的操作方法;理解Spark MLlib编程解决实际问题的方法。 实验要求 掌握基于Spark MLlib的Scala编程环境配置; 掌握Spark MLlib的操作编程方法。 实验内容 参考...
  • 炼数MLlib.zip

    2019-06-19 10:51:30
    该文档是国内某著名培训机构的ppt,主要讲解的是spark上面的mllib机器学习库,讲解仔细,容易理解,讲解人还出了一本书,Spark MLlib机器学习:算法、源码及实战详解,大家可以根据他的书,再根据这个ppt来对该知识...
  • MLlib是Spark中提供机器学习学习函数的库。它是专为在集群上并行运行的情况而设计的。 MLlib的设计理念十分简单:把数据以RDD的形式表示,然后在分布式数据集上调用各种算法。MLlib引入了一些数据类型(比如点和...
  • Spark mllib SVM

    2018-07-31 15:28:07
    package ... import org.apache.log4j.{Level, Logger} import org.apache.spark.mllib.classification.SVMWithSGD import org.apache.spark.mllib.util.MLUtils import org.apache.spark.{SparkConf...
  • SPARK MLLIB机器学习 Spark入门实战系列附带资源 好不容易搜了好多地方找到的
  • MLlib - 带有 Dropout 的逻辑回归 这是 Spark MLlib 的扩展,使用 dropout 正则化实现逻辑回归。 Dropout 正则化通常比 L2 正则化效果更好,因为它强调在分类过程中很少出现但具有判别力的特征的贡献 [2]。 这使得...
  • 1.Spark及其生态圈简介.pdf ...8.SparkMLlib(上)--机器学习及SparkMLlib简介.pdf 8.SparkMLlib(下)--SparkMLlib实战.pdf 9.SparkGraphX介绍及实例.pdf 10.分布式内存文件系统Tachyon介绍及安装部署.pdf
  • Spark MLlib统计操作

    千次阅读 2019-06-07 20:41:25
    package mllib import org.apache.spark.mllib.linalg import org.apache.spark.mllib.linalg.{Matrix, Vectors} import org.apache.spark.mllib.stat.{MultivariateStatisticalSummary, Statistics} import org.....
  • Spark MLlib分布式矩阵

    千次阅读 2019-06-09 19:43:02
    package mllib import org.apache.spark.mllib.linalg import org.apache.spark.mllib.linalg.{DenseMatrix, Matrix, SingularValueDecomposition, Vectors} import org.apache.spark.mllib.linalg.distributed.{B....
  • Spark MLlib学习

    2019-11-11 18:05:40
    《SPARK MLLIB机器学习》_黄美灵 spark主要库 SparkSQL:SQL或Hive查询数据。 Spark Streaming:流数据实时处理,如web日志。 MLlib:机器学习库。 GraphX:图计算库。 目前主要学习使用MLlib和SparkSQL。 ...
  • 本系列”spark mllib机器学习”,均以最新spark2.3.0版本为蓝本进行编写,参考书籍<< spark mllib机器学习 >>黄美灵版,转载请注明出处 GitHub地址:...
  • Spark_LinearRegression_MLLib 该应用程序通过spark和mllib估计具有400个数据集的房价。 应用程序屏幕图像

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,110
精华内容 7,244
关键字:

mllib