spark的机器学习库，包含常见的学习算法和工具如分类、回归、聚类、协同过滤、降维等

使用算法时都需要指定相应的数据集，下面为大家介绍常用的spark ml 数据类型。

1.本地向量(Local Vector)

存储在单台机器上，索引采用0开始的整型表示，值采用Double类型的值表示。Spark MLlib中支持两种类型的矩阵，分别是密度向量(Dense Vector)和稀疏向量(Spasre Vector)，密度向量会存储所有的值包括零值，而稀疏向量存储的是索引位置及值，不存储零值，在数据量比较大时，稀疏向量才能体现它的优势和价值

scala> import org.apache.spark.mllib.linalg.{Vector, Vectors}

注意：scala默认会导入scala.collection.immutable.Vector，所以必须显式导入org.apache.spark.mllib.linalg.Vector

1.1密度向量，零值也存储

scala> val dv: Vector = Vectors.dense(1.0, 0.0, 3.0)

1.2.1创建稀疏向量，指定元素的个数、索引及非零值，数组方式

基于索引(0,2)和值(1,3)创建稀疏向量

scala> val sv1: Vector = Vectors.sparse(3, Array(0, 2), Array(1.0, 3.0))

1.2.2 创建稀疏向量，指定元素的个数、索引及非零值，采用序列方式

scala> val sv2: Vector = Vectors.sparse(3, Seq((0, 1.0), (2, 3.0)))

2.带类标签的特征向量(Labeled point)

Labeled point是Spark MLlib中最重要的数据结构之一，它在无监督学习算法中使用十分广泛，它也是一种本地向量，只不过它提供了类的标签，对于二元分类，它的标签数据为0和1，而对于多类分类，它的标签数据为0，1，2，…。它同本地向量一样，同时具有Sparse和Dense两种实现方式

scala> import org.apache.spark.mllib.regression.LabeledPoint

2.1LabeledPoint第一个参数是类标签数据，第二参数是对应的特征数据

//密度

scala> val pos = LabeledPoint(1.0, Vectors.dense(1.0, 0.0, 3.0))

scala> println(pos.features)

scala> println(pos.label)

//稀疏

scala> val neg = LabeledPoint(0.0, Vectors.sparse(3, Array(0, 2), Array(1.0, 3.0)))

注意:第2个特征值为0，从编程的角度来说，这样做可以减少内存的使用，并提高做矩阵内积时的运算速度

3.本地矩阵(Local matrix)

本地向量是由从0开始的整数下标和Double类型的数值组成。它有稠密向量(dense vector)和稀疏向量(sparse vertor)两种。在列的主要顺序中，它的非零输入值存储在压缩的稀疏列(CSC)格式中

在一维数组[1.0、3.0、5.0、2.0、4.0、6.0]中，对应的矩阵大小(3、2):

本地矩阵的基类是Matrix，提供了两种实现 DenseMatrix和SparseMatrix. 推荐使用工厂方法实现的Matrices来创建本地矩阵.

scala> import org.apache.spark.mllib.linalg.{Matrix, Matrices}

3.1 创建稠密矩阵

scala> val dm: Matrix = Matrices.dense(3, 2, Array(1.0, 3.0, 5.0, 2.0, 4.0, 6.0))

3.2 创建稀疏矩阵

scala> val sm: Matrix = Matrices.sparse(3, 2, Array(0, 1, 3), Array(0, 2, 1), Array(9, 6, 8))

4.分布式矩阵(Distributed matrix)

分布式矩阵有Long类型的行列数据和Double类型值，存储在一个或多个RDDs中

4.1. 行矩阵(RowMatrix)

行矩阵是一个没有行索引的，以行为导向(row-oriented )的分布式矩阵，它的行只支持RDD格式，每一行都是一个本地向量。由于每一行都由一个局部向量表示，所以列的数量是由整数范围所限制的，但是在实际操作中应该要小得多

scala> import org.apache.spark.mllib.linalg.Vector

scala> import org.apache.spark.mllib.linalg.distributed.RowMatrix

scala> import org.apache.spark.mllib.linalg.{Vector, Vectors}

4.1.1 生成DataFrame

scala> val df1 = Seq(

(1.0, 2.0, 3.0),

(1.1, 2.1, 3.1),

(1.2, 2.2, 3.2)).toDF("c1", "c2", "c3")

scala> df1.show

c1  c2  c3

1.0 2.0 3.0

1.1 2.1 3.1

1.2 2.2 3.2

4.1.2 DataFrame转换成RDD[Vector]

scala> val rv1= df1.rdd.map {

x =>Vectors.dense(

x(0).toString().toDouble,

x(1).toString().toDouble,

x(2).toString().toDouble)

}

scala> rv1.collect()

4.1.3 创建行矩阵

scala> val mt1: RowMatrix = new RowMatrix(rv1)

scala> val m = mt1.numRows()

scala> val n = mt1.numCols()

查看：

scala> mt1.rows.collect()

或

scala>mt1.rows.map { x =>

(x(0).toDouble,

x(1).toDouble,

x(2).toDouble)

}.collect()

4.2 CoordinateMatrix坐标矩阵

CoordinateMatrix是一个分布式矩阵，每行数据格式为三元组(i: Long, j: Long, value: Double), i表示行索引，j表示列索引，value表示数值。只有当矩阵的两个维度都很大且矩阵非常稀疏时，才应该使用坐标矩阵。可以通过RDD[MatrixEntry]实例来创建一个CoordinateMatrix。MatrixEntry包装类型(Long, Long, Double)

scala> import org.apache.spark.mllib.linalg.distributed.CoordinateMatrix

scala> import org.apache.spark.mllib.linalg.distributed.MatrixEntry

4.2.1 生成df(行坐标,列坐标,值)

scala> val df = Seq(

(0, 0, 1.1), (0, 1, 1.2), (0, 2, 1.3),

(1, 0, 2.1), (1, 1, 2.2), (1, 2, 2.3),

(2, 0, 3.1), (2, 1, 3.2), (2, 2, 3.3)).toDF("row", "col", "value")

4.2.2 生成入口矩阵

scala> val m1 = df.rdd.map { x =>

val a = x(0).toString().toLong

val b = x(1).toString().toLong

val c = x(2).toString().toDouble

MatrixEntry(a, b, c)

}

scala> m1.collect()

4.2.3 生成坐标矩阵

scala> val m2 = new CoordinateMatrix(m1)

scala> m2.numRows()

scala> m2.numCols()

查看

scala> m2.entries.collect().take(10)