spark 机器学习基础 数据类型

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)