2019年 – 第5页

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 2月 11,2019

Spark ML机器学习：连续型数据处理之给定边界离散化-Bucketizer

Bucketizer将连续的特征列转换成特征桶(buckets)列。这些桶由用户指定。它拥有一个splits参数。例如商城的人群，觉得把人分为50以上和50以下太不精准了，应该分为20岁以下，20-30岁，30-40岁，36-50岁，50以上，那么就得用到数值离散化的处理方法了。离散化就是把特征进行适当的离散处理，比如上面所说的年龄是个连续的特征，但是我把它分为不同的年龄阶段就是把它离散化了，这样更利于我们分析用户行为进行精准推荐。Bucketizer能方便的将一堆数据分成不同的区间。

splits:如果有n+1个splits,那么将有n个桶。桶将由split x和split y共同确定,它的值范围为[x,y),如果是最后一个桶,范围将是[x,y]。splits应该严格递增。负无穷和正无穷必须明确的提供用来覆盖所有的双精度值,否则,超出splits的值将会被认为是一个错误。splits的两个例子是Array(Double.NegativeInfinity, 0.0, 1.0, Double.PositiveInfinity) 和 Array(0.0, 1.0, 2.0)。

注意,如果你并不知道目标列的上界和下界,你应该添加Double.NegativeInfinity和Double.PositiveInfinity作为边界从而防止潜在的超过边界的异常。下面是程序调用的例子。

object BucketizerDemo {
  def main(args: Array[String]): Unit = {
    var spark = SparkSession.builder().appName("BucketizerDemo").master("local[2]").getOrCreate();
    val array = Array((1,13.0),(2,16.0),(3,23.0),(4,35.0),(5,56.0),(6,44.0))
    //将数组转为DataFrame
    val df = spark.createDataFrame(array).toDF("id","age")
    // 设定边界，分为5个年龄组：[0,20),[20,30),[30,40),[40,50),[50,正无穷)
    // 注：人的年龄当然不可能正无穷，我只是为了给大家演示正无穷PositiveInfinity的用法，负无穷是NegativeInfinity。
    val splits = Array(0, 20, 30, 40, 50, Double.PositiveInfinity)
    //初始化Bucketizer对象并进行设定：setSplits是设置我们的划分依据
    val bucketizer = new Bucketizer().setSplits(splits).setInputCol("age").setOutputCol("bucketizer_feature")
    //transform方法将DataFrame二值化。
    val bucketizerdf = bucketizer.transform(df)
    //show是用于展示结果
    bucketizerdf.show
  }

}

输出结果:

+---+----+------------------+
| id| age|bucketizer_feature|
+---+----+------------------+
|  1|13.0|               0.0|
|  2|16.0|               0.0|
|  3|23.0|               1.0|
|  4|35.0|               2.0|
|  5|56.0|               4.0|
|  6|44.0|               3.0|
+---+----+------------------+

作者 east

Spark 2月 11,2019

Spark ML机器学习:连续型数据处理之二值化-Binarizer

Binarization是一个将数值特征转换为二值特征的处理过程。threshold参数表示决定二值化的阈值。值大于阈值的特征二值化为1,否则二值化为0。例如商城有个需求，根据年龄来进行物品推荐，把50以上的人分为老年，50以下分为非老年人，那么我们根据二值化可以很简单的把50以上的定为1，50以下的定为0。这样就方便我们后续的推荐了。Binarizer就是根据阈值进行二值化,大于阈值的为1.0,小于等于阈值的为0.0


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

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

    // $example on$
    val data = Array((0, 0.1), (1, 0.8), (2, 0.6))
    val dataFrame = spark.createDataFrame(data).toDF("id", "feature")
    // transform 开始转换,将该列数据二值化，大于阈值的为1.0，否则为0.0
    val binarizer: Binarizer = new Binarizer()
      .setInputCol("feature")
      .setOutputCol("binarized_feature")
      .setThreshold(0.5)

    val binarizedDataFrame = binarizer.transform(dataFrame)

    println(s"Binarizer output with Threshold = ${binarizer.getThreshold}")
    binarizedDataFrame.show()
    // $example off$

    spark.stop()
  }
}

输出结果:

+---+----+-----------------+
| id| age|binarized_feature|
+---+----+-----------------+
|  1|34.0|              0.0|
|  2|56.0|              1.0|
|  3|58.0|              1.0|
|  4|23.0|              0.0|
+---+----+-----------------+

作者 east

Android 1月 16,2019

自动化方法模拟Android手机点击、触屏事件

使用apk来自动化测试，需要手机有root权限，所以采用写java程序，利用adb shell来实现自动化测试。

一、所需知识

最基础的adb shell 指令。input tab 等。

二、所需环境
硬件：一台电脑、一部手机、一根数据线。软件：jdk、adb工具
三、编码

功能：模拟用户打开微信，并进行搜索就这么完成了。其实这里用shell命令模拟用户操作还是有些问题的，比如说控件长按(sendevent)，好难理解，而且需要跟其中传递的控件坐标参数应该要跟屏幕分辨率联系起来，实际应用范围不是很广泛。

import java.awt.AWTException;
import java.io.DataOutputStream;
import java.io.IOException;

public class TencentTest {

private String[] search = {
                   //  "adb shell",
                 //    "sleep 3",
                     "input keyevent 3",// 返回到主界面，数值与按键的对应关系可查阅KeyEvent
                     "sleep 1",// 等待1秒
                     "am start -n com.tencent.mm/com.tencent.mm.ui.LauncherUI",// 打开微信的启动界面，am命令的用法可自行百度、Google
                     "sleep 3",// 等待3秒
                     "am start -n com.tencent.mm/com.tencent.mm.plugin.search.ui.SearchUI",// 打开微信的搜索
                     "input text 123",// 像搜索框中输入123，但是input不支持中文，蛋疼，而且这边没做输入法处理，默认会自动弹出输入法
           };

  public static void main(String[] args) throws AWTException,         InterruptedException, IOException
    {
      TencentTest tencentTest = new TencentTest();
      //如果input text中有中文，可以将中文转成unicode进行input,没有测试，只是觉得这个思路是可行的
      tencentTest.search[5] = tencentTest.chineseToUnicode(tencentTest.search[5]);
      tencentTest.execShell(tencentTest.search);

    }

/**

执行Shell命令
- @param commands
要执行的命令数组
*/
public void execShell(String[] commands) {
// 获取Runtime对象
Runtime runtime = Runtime.getRuntime(); DataOutputStream os = null;
try {
// 获取root权限，这里大量申请root权限会导致应用卡死，可以把Runtime和Process放在Application中初始化
Process process = runtime.exec(“adb shell”);
os = new DataOutputStream(process.getOutputStream());
for (String command : commands) {
if (command == null) {
continue;
} // donnot use os.writeBytes(commmand), avoid chinese charset // error os.write(command.getBytes()); os.writeBytes("\n"); os.flush(); } os.writeBytes("exit\n"); os.flush(); process.waitFor(); } catch (Exception e) {
e.printStackTrace();
}
}

/**

把中文转成Unicode码
@param str
@return
*/
public String chineseToUnicode(String str){
String result=””;
for (int i = 0; i < str.length(); i++){ int chr1 = (char) str.charAt(i); if(chr1>=19968&&chr1<=171941){//汉字范围 \u4e00-\u9fa5 (中文)
result+=”\u” + Integer.toHexString(chr1);
}else{
result+=str.charAt(i);
}
}
return result;
}

/**

判断是否为中文字符
@param c
@return
*/
public boolean isChinese(char c) {
Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
|| ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
|| ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
|| ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
|| ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
|| ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) {
return true;
}
return false;
}

}

效果图如下:

作者 east

年度归档2019