Spark – 第7页 – gitweixin

Spark 4月 18,2019

Spark本地向量(Local vector)详细解析

一个本地向量拥有从0开始的integer类型的索引以及double类型的值，它保存在单台机器上面。MLlib支持两种类型的本地向量：稠密(dense)向量和稀疏(sparse)向量。一个稠密向量通过一个double类型的数组保存数据，这个数组表示向量的条目值(entry values)；一个稀疏向量通过两个并行的数组（indices和values）保存数据。例如：

向量（5.2，0.0，5.5）

密集向量表示：[5.2，0.0，5.5]

稀疏向量表示：（3，[0,2]，[5.2,5.5]） # 3是向量（5.2，0.0，5.5）的长度，除去0值外，其他两个值的索引和值分别构成了数组[0,2]和数组[5.2,5.5]。

Vector是所有局部向量的基类，Dense-Vector和SparseVector都是Vector的具体实现。

本地向量的基类是Vector，Spark提供了两种实现： DenseVector和SparseVector。 Spark官方推荐使用Vectors中实现的工厂方法去创建本地向量。下面是创建本地向量的例子。

 
 
import org.apache.spark.mllib.linalg.{Vector, Vectors} 
// 创建一个dense vector (5.2, 0.0, 5.5).
 val dv: Vector = Vectors.dense(5.2, 0.0, 5.5) 
// 创建一个sparse vector (5.2, 0.0, 5.5)并且指定它的索引和值
 val sv1: Vector = Vectors.sparse(3, Array(0, 2), Array(5.2, 5.5)) 
// 创建一个sparse vector (5.2, 0.0, 5.5)并且指定它的索引和值，通过指定非0的值，位置0是5.2，位置2是5.5 
val sv2: Vector = Vectors.sparse(3, Seq((0, 5.2), (2, 5.5)))

注意，Scala默认引入scala.collection.immutable.Vector，这里我们需要主动引入MLLib中的org.apache.spark.mllib.linalg.Vector来操作。我们可以看看Vectors对象的部分方法。

作者 east

Spark 2月 12,2019

Spark ML机器学习：元素智能乘积-ElementwiseProduct

ElementwiseProduct对每一个输入向量乘以一个给定的“权重”向量。换句话说，就是通过一个乘子对数据集的每一列进行缩放。这个转换可以表示为如下的形式：

实例：

import org.apache.spark.sql.SparkSession

object ElementwiseProductExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("ElementwiseProductExample")
      .getOrCreate()

    // $example on$
    // Create some vector data; also works for sparse vectors
    val dataFrame = spark.createDataFrame(Seq(
      ("a", Vectors.dense(1.0, 2.0, 3.0)),
      ("b", Vectors.dense(4.0, 5.0, 6.0)))).toDF("id", "vector")

    val transformingVector = Vectors.dense(0.0, 1.0, 2.0)
    val transformer = new ElementwiseProduct()
      .setScalingVec(transformingVector)
      .setInputCol("vector")
      .setOutputCol("transformedVector")

    // Batch transform the vectors to create new column:
    transformer.transform(dataFrame).show()
    // $example off$

    spark.stop()
  }
}

输出结果:

+—+————-+—————–+
| id| vector|transformedVector|
+—+————-+—————–+
| a|[1.0,2.0,3.0]| [0.0,2.0,6.0]|
| b|[4.0,5.0,6.0]| [0.0,5.0,12.0]|
+—+————-+—————–+

作者 east

Spark 2月 11,2019

Spark ML机器学习：SQLTransformer

我们都很喜欢sql语句，简单好用又熟悉，那么Spark ML很人性化的为我们提供了SQLTransformer类，使得我们能用我们熟悉的SQL来做特征转化。它支持SparkSql中的所有select选择语句,sum(),count(),group by,order by等等都可以用！形如”SELECT …FROM __THIS__”。’__THIS__’代表输入数据的基础表。

SQLTransformer实现了一种转换,这个转换通过SQl语句来定义。目前我们仅仅支持的SQL语法是像SELECT ... FROM __THIS__ ...的形式。这里__THIS__表示输入数据集相关的表。例如,SQLTransformer支持的语句如下:

SELECT a, a + b AS a_b FROM __THIS__
SELECT a, SQRT(b) AS b_sqrt FROM __THIS__ where a > 5
SELECT a, b, SUM(c) AS c_sum FROM __THIS__ GROUP BY a, b

例子

假设我们拥有下面的DataFrame,它的列名是id,v1,v2。

id  |  v1 |  v2
----|-----|-----
 0  | 1.0 | 3.0
 2  | 2.0 | 5.0

下面是语句SELECT *, (v1 + v2) AS v3, (v1 * v2) AS v4 FROM __THIS__的输出结果。

 id |  v1 |  v2 |  v3 |  v4
----|-----|-----|-----|-----
 0  | 1.0 | 3.0 | 4.0 | 3.0
 2  | 2.0 | 5.0 | 7.0 |10.0

下面是程序调用的例子。

// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.SQLTransformer
// $example off$
import org.apache.spark.sql.SparkSession

object SQLTransformerExample {
  def main(args: Array[String]) {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
        .config(sparkConf)
      .appName("SQLTransformerExample")
      .getOrCreate()

    // $example on$
    val df = spark.createDataFrame(
      Seq((0, 1.0, 3.0), (2, 2.0, 5.0))).toDF("id", "v1", "v2")

    val sqlTrans = new SQLTransformer().setStatement(
      "SELECT *, (v1 + v2) AS v3, (v1 * v2) AS v4 FROM __THIS__")

    sqlTrans.transform(df).show()
    // $example off$

    spark.stop()
  }
}

输出结果：

+—+—+—+—+—-+
| id| v1| v2| v3| v4|
+—+—+—+—+—-+
| 0|1.0|3.0|4.0| 3.0|
| 2|2.0|5.0|7.0|10.0|
+—+—+—+—+—-+

作者 east

Spark 2月 11,2019

作者 east

Spark 2月 11,2019

Spark ML机器学习：多项式转化-PolynomialExpansion

Polynomial expansion是一个将特征展开到多元空间的处理过程，
运用于特征值进行一些多项式的转化，比如平方啊，三次方。它通过n-degree结合原始的维度来定义。比如设置degree为2就可以将(x, y)转化为(x, x x, y, x y, y y)。PolynomialExpansion提供了这个功能。下面的例子展示了如何将特征展开为一个3-degree多项式空间。


// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.PolynomialExpansion
import org.apache.spark.ml.linalg.Vectors
// $example off$
import org.apache.spark.sql.SparkSession

object PolynomialExpansionExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("PolynomialExpansionExample")
      .getOrCreate()

    // $example on$
    val data = Array(
      Vectors.dense(2.0, 1.0),
      Vectors.dense(0.0, 0.0),
      Vectors.dense(3.0, -1.0)
    )
    val df = spark.createDataFrame(data.map(Tuple1.apply)).toDF("features")
    //setDegree表示多项式最高次幂 比如1.0,5.0可以是 三次：1.0^3 5.0^3 1.0+5.0^2 二次：1.0^2+5.0 1.0^2 5.0^2 1.0+5.0 一次：1.0 5.0
    val polyExpansion = new PolynomialExpansion()
      .setInputCol("features")
      .setOutputCol("polyFeatures")
      .setDegree(3)

    val polyDF = polyExpansion.transform(df)
    polyDF.show(false)
    // $example off$

    spark.stop()
  }
}

输出结果为：

+---+---------+-----------------------------------------------+
|id |features |Polynomial_features                            |
+---+---------+-----------------------------------------------+
|0  |[1.0,5.0]|[1.0,1.0,1.0,5.0,5.0,5.0,25.0,25.0,125.0]      |
|1  |[2.0,1.0]|[2.0,4.0,8.0,1.0,2.0,4.0,1.0,2.0,1.0]          |
|2  |[4.0,8.0]|[4.0,16.0,64.0,8.0,32.0,128.0,64.0,256.0,512.0]|
+---+---------+-----------------------------------------------+

作者 east

Spark 2月 11,2019

Spark ML机器学习：N-gram

一个n-gram是一个包含n个tokens(如词)的序列。NGram可以将输入特征转换为n-grams。

NGram输入一系列的序列,参数n用来决定每个n-gram的词个数。输出包含一个n-grams序列,每个n-gram表示一个划定空间的连续词序列。如果输入序列包含的词少于n,将不会有输出。
N-Gram认为语言中每个单词只与其前面长度 N-1 的上下文有关。主要分为bigram和trigram，bigram假设下一个词的出现依赖它前面的一个词，trigram假设下一个词的出现依赖它前面的两个词。在SparkML中用NGram类实现，setN(2)为bigram，setN(3)为trigram。


// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.NGram
// $example off$
import org.apache.spark.sql.SparkSession

/**
  * N-Gram认为语言中每个单词只与其前面长度 N-1 的上下文有关。主要分为bigram和trigram，
  * bigram假设下一个词的出现依赖它前面的一个词，trigram假设下一个词的出现依赖它前面的两个词。
  * 在SparkML中用NGram类实现，setN(2)为bigram，setN(3)为trigram。
  */
object NGramExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("NGramExample")
      .getOrCreate()

    // $example on$
    val wordDataFrame = spark.createDataFrame(Seq(
      (0, Array("Hi", "I", "heard", "about", "Spark")),
      (1, Array("I", "wish", "Java", "could", "use", "case", "classes")),
      (2, Array("Logistic", "regression", "models", "are", "neat"))
    )).toDF("id", "words")

    val ngram = new NGram().setN(2).setInputCol("words").setOutputCol("ngrams")

    val ngramDataFrame = ngram.transform(wordDataFrame)
    ngramDataFrame.select("ngrams").show(false)
    // $example off$

    spark.stop()
  }
}

输出结果：

+——————————————————————+
|ngrams |
+——————————————————————+
|[Hi I, I heard, heard about, about Spark] |
|[I wish, wish Java, Java could, could use, use case, case classes]|
|[Logistic regression, regression models, models are, are neat] |
+——————————————————————+

作者 east

Spark 2月 11,2019

Spark ML机器学习：归一化之最小最大值标准化-MinMaxScaler

MinMaxScaler转换由向量行组成的数据集,将每个特征调整到一个特定的范围(通常是[0,1])。它有下面两个参数:

min:默认是0。转换的下界,被所有的特征共享。
max:默认是1。转换的上界,被所有特征共享。

MinMaxScaler计算数据集上的概要统计数据,产生一个MinMaxScalerModel。然后就可以用这个模型单独的转换每个特征到特定的范围。特征E被转换后的值可以用下面的公式计算:

$$\frac{e_{i} – E_{min}}{E_{max} – E_{min}} * (max – min) + min$$

对于E_{max} == E_{min}的情况,Rescaled(e_i) = 0.5 * (max + min)。

注意,由于0值有可能转换成非0的值,所以转换的输出为DenseVector,即使输入为稀疏的数据也一样。下面的例子展示了如何将特征转换到[0,1]。例子：


// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.MinMaxScaler
import org.apache.spark.ml.linalg.Vectors
// $example off$
import org.apache.spark.sql.SparkSession

object MinMaxScalerExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("MinMaxScalerExample")
      .getOrCreate()

    // $example on$
    val dataFrame = spark.createDataFrame(Seq(
      (0, Vectors.dense(1.0, 0.1, -1.0)),
      (1, Vectors.dense(2.0, 1.1, 1.0)),
      (2, Vectors.dense(3.0, 10.1, 3.0))
    )).toDF("id", "features")

    val scaler = new MinMaxScaler()
      .setInputCol("features")
      .setOutputCol("scaledFeatures")

    // Compute summary statistics and generate MinMaxScalerModel
    val scalerModel = scaler.fit(dataFrame)

    // rescale each feature to range [min, max].
    val scaledData = scalerModel.transform(dataFrame)
    println(s"Features scaled to range: [${scaler.getMin}, ${scaler.getMax}]")
    scaledData.select("features", "scaledFeatures").show()
    // $example off$

    spark.stop()
  }
}

结果：

+————–+————–+
| features|scaledFeatures|
+————–+————–+
|[1.0,0.1,-1.0]| [0.0,0.0,0.0]|
| [2.0,1.1,1.0]| [0.5,0.1,0.5]|
|[3.0,10.1,3.0]| [1.0,1.0,1.0]|
+————–+————–+

作者 east

Spark 2月 11,2019

Spark ML机器学习：绝对值最大标准化-MaxAbsScaler

数据归一化，以房价预测为案例，房价(y)通常与离市中心距离(x1)、面积(x2)、楼层(x3)有关，设y=ax1+bx2+cx3，那么abc就是我们需要重点解决的参数。但是有个问题，面积一般数值是比较大的，100平甚至更多，而距离一般都是几公里而已，b参数只要一点变化都能对房价产生巨大影响，而a的变化对房价的影响相对就小很多了。显然这会影响最终的准确性，毕竟距离可是个非常大的影响因素啊。所以, 需要使用特征的归一化, 取值跨度大的特征数据, 我们浓缩一下, 跨度小的括展一下, 使得他们的跨度尽量统一。
归一化就是将所有特征值都等比地缩小到0-1或者-1到1之间的区间内。其目的是为了使特征都在相同的规模中。

MaxAbsScaler转换由向量列组成的数据集,将每个特征调整到[-1,1]的范围,它通过每个特征内的最大绝对值来划分。它不会移动和聚集数据,因此不会破坏任何的稀疏性。

MaxAbsScaler计算数据集上的统计数据,生成MaxAbsScalerModel,然后使用生成的模型分别的转换特征到范围[-1,1]。下面是程序调用的例子。


// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.MaxAbsScaler
import org.apache.spark.ml.linalg.Vectors
// $example off$
import org.apache.spark.sql.SparkSession
/*
所有值都扫描一遍，计算出最大最小值，比如1000的话那么absMax=1000。最后返回MaxAbsScalerModel
第一列1.0、2.0、4.0中最小为1.0，最大为4.0，2.0为0.5，第二列0.1、1.0、10.0依次类推
 */

object MaxAbsScalerExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("MaxAbsScalerExample")
      .getOrCreate()

    // $example on$
    val dataFrame = spark.createDataFrame(Seq(
      (0, Vectors.dense(1.0, 0.1, -8.0)),
      (1, Vectors.dense(2.0, 1.0, -4.0)),
      (2, Vectors.dense(4.0, 10.0, 8.0))
    )).toDF("id", "features")

    val scaler = new MaxAbsScaler()
      .setInputCol("features")
      .setOutputCol("scaledFeatures")

    // Compute summary statistics and generate MaxAbsScalerModel
    val scalerModel = scaler.fit(dataFrame)

    // rescale each feature to range [-1, 1]
    val scaledData = scalerModel.transform(dataFrame)
    scaledData.select("features", "scaledFeatures").show()
    // $example off$

    spark.stop()
  }
}

结果：

+————–+—————-+
| features| scaledFeatures|
+————–+—————-+
|[1.0,0.1,-8.0]|[0.25,0.01,-1.0]|
|[2.0,1.0,-4.0]| [0.5,0.1,-0.5]|
|[4.0,10.0,8.0]| [1.0,1.0,1.0]|
+————–+—————-+

作者 east

Spark 2月 11,2019

Spark ML机器学习：标准化-StandardScaler

1 动机

对于同一个特征，不同的样本中的取值可能会相差非常大，一些异常小或异常大的数据会误导模型的正确训练；另外，如果数据的分布很分散也会影响训练结果。以上两种方式都体现在方差会非常大。此时，我们可以将特征中的值进行标准差标准化，即转换为均值为0，方差为1的正态分布。如果特征非常稀疏，并且有大量的0（现实应用中很多特征都具有这个特点），Z-score 标准化的过程几乎就是一个除0的过程，结果不可预料。所以在训练模型之前，一定要对特征的数据分布进行探索，并考虑是否有必要将数据进行标准化。基于特征值的均值（mean）和标准差（standard deviation）进行数据的标准化。它的计算公式为：标准化数据=(原数据-均值)/标准差。标准化后的变量值围绕0上下波动，大于0说明高于平均水平，小于0说明低于平均水平。

因为在原始的资料中，各变数的范围大不相同。对于某些机器学习的算法，若没有做过标准化，目标函数会无法适当的运作。举例来说，多数的分类器利用两点间的距离计算两点的差异，若其中一个特征具有非常广的范围，那两点间的差异就会被该特征左右，因此，所有的特征都该被标准化，这样才能大略的使各特征依比例影响距离。另外一个做特征缩放的理由是他能使加速梯度下降法的收敛。

2 方法

2.1 重新缩放

最简单的方式是重新缩放特征的范围到[0, 1]或[-1, 1]，依据原始的资料选择目标范围，通式如下：

2.2 标准化

在机器学习中，我们可能要处理不同种类的资料，例如，音讯和图片上的像素值，这些资料可能是高维度的，资料标准化后会使每个特征中的数值平均变为0(将每个特征的值都减掉原始资料中该特征的平均)、标准差变为1，这个方法被广泛的使用在许多机器学习算法中。

3 实例


// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.StandardScaler
// $example off$
import org.apache.spark.sql.SparkSession

object StandardScalerExample {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("StandardScalerExample")
      .getOrCreate()

    // $example on$
    val dataFrame = spark.read.format("libsvm").load("D:/java/spark/spark/data/mllib/sample_libsvm_data.txt")

    val scaler = new StandardScaler()
      .setInputCol("features")
      .setOutputCol("scaledFeatures")
      .setWithStd(true)
      .setWithMean(false)

    // Compute summary statistics by fitting the StandardScaler.
    val scalerModel = scaler.fit(dataFrame)

    // Normalize each feature to have unit standard deviation.
    val scaledData = scalerModel.transform(dataFrame)
    scaledData.show()
    // $example off$

    spark.stop()
  }
}
// scalastyle:on println

结果：

+—–+——————–+——————–+
|label| features| scaledFeatures|
+—–+——————–+——————–+
| 0.0|(692,[127,128,129…|(692,[127,128,129…|
| 1.0|(692,[158,159,160…|(692,[158,159,160…|
| 1.0|(692,[124,125,126…|(692,[124,125,126…|
| 1.0|(692,[152,153,154…|(692,[152,153,154…|
| 1.0|(692,[151,152,153…|(692,[151,152,153…|
| 0.0|(692,[129,130,131…|(692,[129,130,131…|
| 1.0|(692,[158,159,160…|(692,[158,159,160…|
| 1.0|(692,[99,100,101,…|(692,[99,100,101,…|
| 0.0|(692,[154,155,156…|(692,[154,155,156…|
| 0.0|(692,[127,128,129…|(692,[127,128,129…|
| 1.0|(692,[154,155,156…|(692,[154,155,156…|
| 0.0|(692,[153,154,155…|(692,[153,154,155…|
| 0.0|(692,[151,152,153…|(692,[151,152,153…|
| 1.0|(692,[129,130,131…|(692,[129,130,131…|
| 0.0|(692,[154,155,156…|(692,[154,155,156…|
| 1.0|(692,[150,151,152…|(692,[150,151,152…|
| 0.0|(692,[124,125,126…|(692,[124,125,126…|
| 0.0|(692,[152,153,154…|(692,[152,153,154…|
| 1.0|(692,[97,98,99,12…|(692,[97,98,99,12…|
| 1.0|(692,[124,125,126…|(692,[124,125,126…|
+—–+——————–+——————–+

作者 east

Spark 2月 11,2019

Spark ML机器学习：连续型数据处理之给定分位数离散化-QuantileDiscretizer

QuantileDiscretizer输入连续的特征列,输出分箱的类别特征。分箱数是通过参数numBuckets来指定的。箱的范围是通过使用近似算法(见approxQuantile )来得到的。近似的精度可以通过relativeError参数来控制。当这个参数设置为0时,将会计算精确的分位数。箱的上边界和下边界分别是正无穷和负无穷时, 取值将会覆盖所有的实数值。

例子

假设我们有下面的DataFrame,它的列名是id,hour。

 id | hour
----|------
 0  | 18.0
----|------
 1  | 19.0
----|------
 2  | 8.0
----|------
 3  | 5.0
----|------
 4  | 2.2

hour是类型为DoubleType的连续特征。我们想将连续特征转换为一个分类特征。给定numBuckets为3,我们可以得到下面的结果。

id  | hour | result
----|------|------
 0  | 18.0 | 2.0
----|------|------
 1  | 19.0 | 2.0
----|------|------
 2  | 8.0  | 1.0
----|------|------
 3  | 5.0  | 1.0
----|------|------
 4  | 2.2  | 0.0


// $example on$
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.QuantileDiscretizer
// $example off$
import org.apache.spark.sql.SparkSession

/**
  * 连续型数据处理之给定分位数离散化
  */
object QuantileDiscretizerExample {
  def main(args: Array[String]) {
    val sparkConf = new SparkConf();
    sparkConf.setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val spark = SparkSession
      .builder
      .config(sparkConf)
      .appName("QuantileDiscretizerExample")
      .getOrCreate()

    // $example on$
    val data = Array((0, 18.0), (1, 19.0), (2, 8.0), (3, 5.0), (4, 2.2))
    val df = spark.createDataFrame(data).toDF("id", "hour")
    // $example off$
    // Output of QuantileDiscretizer for such small datasets can depend on the number of
    // partitions. Here we force a single partition to ensure consistent results.
    // Note this is not necessary for normal use cases
      .repartition(1)

    // $example on$
    val discretizer = new QuantileDiscretizer()
      .setInputCol("hour")
      .setOutputCol("result")
      .setNumBuckets(3)

    val result = discretizer.fit(df).transform(df)
    result.show(false)
    // $example off$

    spark.stop()
  }
}

结果：

+—+—-+——+
|id |hour|result|
+—+—-+——+
|0 |18.0|2.0 |
|1 |19.0|2.0 |
|2 |8.0 |1.0 |
|3 |5.0 |1.0 |
|4 |2.2 |0.0 |
+—+—-+——+

作者 east

分类归档Spark