大数据系列 | Spark MLlib矩阵基本数据类型

Spark MLlib矩阵（基本数据类型）

⼀、本地矩阵（Local Matrix）：

本地矩阵具有整型的⾏、列索引值和双精度浮点型的元素值，它存储在单机上。MLlib⽀持稠密矩阵DenseMatrix和稀疏矩阵Sparse Matrix两种本地矩阵，稠密矩阵将所有元素的值存储在⼀个列优先（Column-major）的双精度型数组中，⽽稀疏矩阵则将⾮零元素以列优先的CSC（Compressed SparseColumn）模式进⾏存储。

scala>import org.apache.spark.mllib.linalg.{Matrix, Matrices}
import org.apache.spark.mllib.linalg.{Matrix, Matrices}
// 创建⼀个3⾏2列的稠密矩阵[ [1.0,2.0], [3.0,4.0], [5.0,6.0] ]
// 请注意，这⾥的数组参数是列先序的！
scala> val dm: Matrix = Matrices.dense(3, 2, Array(1.0, 3.0, 5.0, 2.0,
4.0, 6.0))
dm: org.apache.spark.mllib.linalg.Matrix =
1.0 2.0
3.0 4.0
5.0 6.0


// 创建⼀个3⾏2列的稀疏矩阵[ [9.0,0.0], [0.0,8.0], [0.0,6.0]]
// 第⼀个数组参数表示列指针，即每⼀列元素的开始索引值+⾮0元素
总数
// 第⼆个数组参数表示⾏索引，即对应的元素是属于哪⼀⾏
// 第三个数组即是按列先序排列的所有⾮零元素，通过列指针和⾏索引即可判断每个元素所在的位置
scala> val sm: Matrix = Matrices.sparse(3, 2, Array(0, 1, 3), Array(0, 1,
2), Array(9, 8, 6))
sm: org.apache.spark.mllib.linalg.Matrix =
3 x 2 CSCMatrix
(0,0) 9.0
(2,1) 6.0
(1,1) 8.0

二、分布式矩阵（Distributed Matrix）

分布式矩阵由⻓整型的⾏列索引值和双精度浮点型的元素值组成。它可以分布式地存储在⼀个或多个RDD上，MLlib提供了三种分布式矩阵的存储⽅案：⾏矩阵RowMatrix，索引⾏矩阵IndexedRowMatrix、坐标矩阵CoordinateMatrix和分块矩阵Block Matrix。它们都属于org.apache.spark.mllib.linalg.distributed包。

（⼀）⾏矩阵（RowMatrix）

⾏矩阵RowMatrix是最基础的分布式矩阵类型。每⾏是⼀个本地向量，⾏索引⽆实际意义（即⽆法直接使⽤）。数据存储在⼀个由⾏组成的RDD中，其中每⼀⾏都使⽤⼀个本地向量来进⾏存储。由于⾏是通过本地向量来实现的，故列数（即⾏的维度）被限制在普通整型（integer）的范围内。在实际使⽤时，由于单机处理本地向量的存储和通信代价，⾏维度更是需要被控制在⼀个更⼩的范围之内。RowMatrix可通过⼀个RDD[Vector]的实例来创建：

scala> import org.apache.spark.rdd.RDD
import org.apache.spark.rdd.RDD
scala> import org.apache.spark.mllib.linalg.{Vector,Vectors}
import org.apache.spark.mllib.linalg.{Vector,Vectors}
scala> import org.apache.spark.mllib.linalg.distributed.RowMatrix
import org.apache.spark.mllib.linalg.distributed.RowMatrix
// 创建两个本地向量dv1 dv2
scala> val dv1 : Vector = Vectors.dense(1.0,2.0,3.0)
dv1: org.apache.spark.mllib.linalg.Vector = [1.0,2.0,3.0]
scala> val dv2 : Vector = Vectors.dense(2.0,3.0,4.0)
dv2: org.apache.spark.mllib.linalg.Vector = [2.0,3.0,4.0]
// 使⽤两个本地向量创建⼀个RDD[Vector]
scala> val rows : RDD[Vector] = sc.parallelize(Array(dv1,dv2))
rows: org.apache.spark.rdd.RDD[org.apache.spark.mllib.linalg.Vector]
= ParallelCollectionRDD[13] at parallelize at <console>:38
// 通过RDD[Vector]创建⼀个⾏矩阵
scala> val mat : RowMatrix = new RowMatrix(rows)
mat: org.apache.spark.mllib.linalg.distributed.RowMatrix =
org.apache.spark.mllib.linalg.distributed.RowMatrix@76fc0fa
//可以使⽤numRows()和numCols()⽅法得到⾏数和列数
scala> mat.numRows()
res0: Long = 2
scala> mat.numCols()
res1: Long = 3
scala> mat.rows.foreach(println)
[1.0,2.0,3.0]
[2.0,3.0,4.0]

（⼆）索引⾏矩阵（IndexedRowMatrix）

索引⾏矩阵IndexedRowMatrix与RowMatrix相似，但它的每⼀⾏都带有⼀个有意义的⾏索引值，这个索引值可以被⽤来识别不同⾏，或是进⾏诸如join之类的操作。其数据存储在⼀个由IndexedRow组成的RDD⾥，即每⼀⾏都是⼀个带⻓整型索引的本地向量。与RowMatrix类似，IndexedRowMatrix的实例可以通过
RDD[IndexedRow]实例来创建。如下代码段所示（接上例）：

scala>import org.apache.spark.mllib.linalg.distributed.{IndexedRow,
IndexedRowMatrix}
import org.apache.spark.mllib.linalg.distributed.{IndexedRow,
IndexedRowMatrix}
// 通过本地向量dv1 dv2来创建对应的IndexedRow
// 在创建时可以给定⾏的索引值，如这⾥给dv1的向量赋索引值1，dv2赋索引值2
scala> val idxr1 = IndexedRow(1,dv1)
idxr1: org.apache.spark.mllib.linalg.distributed.IndexedRow =
IndexedRow(1,[1.0,2.0,3.0])
scala> val idxr2 = IndexedRow(2,dv2)
idxr2: org.apache.spark.mllib.linalg.distributed.IndexedRow =
IndexedRow(2,[2.0,3.0,4.0])
// 通过IndexedRow创建RDD[IndexedRow]
scala> val idxrows = sc.parallelize(Array(idxr1,idxr2))
idxrows:
org.apache.spark.rdd.RDD[org.apache.spark.mllib.linalg.distributed.In
dexedRow] = ParallelCollectionRDD[14] at parallelize at <console>:45
// 通过RDD[IndexedRow]创建⼀个索引⾏矩阵
scala> val idxmat: IndexedRowMatrix = new
IndexedRowMatrix(idxrows)
idxmat: org.apache.spark.mllib.linalg.distributed.IndexedRowMatrix =
org.apache.spark.mllib.linalg.distributed.IndexedRowMatrix@532887
bc
//打印
scala> idxmat.rows.foreach(println)
 IndexedRow(1,[1.0,2.0,3.0])
 IndexedRow(2,[2.0,3.0,4.0])

（三）坐标矩阵（Coordinate Matrix）

坐标矩阵CoordinateMatrix是⼀个基于矩阵项构成的RDD的分布式矩阵。每⼀个矩阵项MatrixEntry都是⼀个三元组：(i: Long, j: Long, value:Double)，其中i是⾏索引，j是列索引，value是该位置的值。坐标矩阵⼀般在矩阵的两个维度都很⼤，且矩阵⾮常稀疏的时候使⽤。CoordinateMatrix实例可通过RDD[MatrixEntry]实例来创建，其中每⼀个矩阵项都是⼀个(rowIndex, colIndex, elem)的三元组：

scala> import org.apache.spark.mllib.linalg.distributed.{CoordinateMatrix, MatrixEntry}
// 创建两个矩阵项ent1和ent2，每⼀个矩阵项都是由索引和值构成的三元组：
scala> val ent1 = new MatrixEntry(0,1,0.5)
ent1: org.apache.spark.mllib.linalg.distributed.MatrixEntry =
MatrixEntry(0,1,0.5)
scala> val ent2 = new MatrixEntry(2,2,1.8)
ent2: org.apache.spark.mllib.linalg.distributed.MatrixEntry =
MatrixEntry(2,2,1.8)
// 创建RDD[MatrixEntry]
scala> val entries : RDD[MatrixEntry] =
sc.parallelize(Array(ent1,ent2))
entries: 
org.apache.spark.rdd.RDD[org.apache.spark.mllib.linalg.distributed.M
atrixEntry] = ParallelCollectionRDD[15] at parallelize at <console>:42
// 通过RDD[MatrixEntry]创建⼀个坐标矩阵
scala> val coordMat: CoordinateMatrix = new CoordinateMatrix(entries)
coordMat:org.apache.spark.mllib.linalg.distributed.CoordinateMatrix=org.apache.spark.mllib.linalg.distributed.CoordinateMatrix@25b2d46
5
//打印
scala> coordMat.entries.foreach(println)
MatrixEntry(0,1,0.5)
MatrixEntry(2,2,1.8)