Spark-MLlib基础数据类型

MLlib基础数据类型

多种数据类型

类型名称	释义
Local vector	本地向量集。主要向Spark提供一组可进行操作的数据集合
Labeled point	向量标签。让用户能够分类不同的数据集合
Local matrix	本地矩阵。将数据集合以矩阵形式存储在本地计算机中
Distributed matrix	分布式矩阵。将数据集合以矩阵形式存储在分布式计算机中

本地向量集

本地向量集分为稀疏型数据集和密集型数据集。密集型数据集会将数据集作为一个集合的形式整体存储，稀疏型数据集将数据集按照数据集的大小，数据的下标，数据集本身存储。如果存入一个数据集(9,5,2,7)，密集型数据集会存储为(9,5,2,7)，稀疏型数据集会存储为(4,(1,2,3,4),(9,5,2,7))。

代码示例如下：

import org.apache.spark.mllib.linalg.{Vector,Vectors}
object testVector {
  def main(args: Array[String]): Unit = {
    //建立密集向量
    val vd = Vectors.dense(9,5,2,7)
    //打印稀疏向量
    println(vd)
    //建立稀疏向量
    val vs = Vectors.sparse(4,Array(0,1,2,3),Array(9,5,2,7))
    //打印稀疏向量
    println(vs)
  }
}

----------
[9.0,5.0,2.0,7.0]
(4,[0,1,2,3],[9.0,5.0,2.0,7.0])

向量标签

向量标签用于对MLlib中的不同值做标记，可以将不同的数据集分为若干份并进行标记。

import org.apache.spark.mllib.linalg.{Vector,Vectors}
import org.apache.spark.mllib.regression.LabeledPoint

object testLabeledPoint{
    def main(args: Array[String]): Unit = {
        // 建立密集向量
        val vd = Vectors.dense(9,5,2,7)
        // 对密集向量建立标记点
        val pos = LabeledPoint(1,vd)
        // 打印标记点内容数据
        println(pos.features)
        // 打印既定标记
        println(pos.label)
        // 建立稀疏向量
        val vs = Vectors.sparse(4,Array(0,1,2,3),Array(9,5,2,7))
        // 对稀疏向量建立标记点
        val neg = LabeledPoint(2,vs)
        // 打印标记点内容数据
        println(neg.features)
        // 打印既定标记
        println(neg.label)

        println(neg)
    }
}

----------
[9.0,5.0,2.0,7.0]
1.0
(4,[0,1,2,3],[9.0,5.0,2.0,7.0])
2.0
(2.0,(4,[0,1,2,3],[9.0,5.0,2.0,7.0]))

向量标签也可以通过读取固定格式的数据集来产生建立向量标签：

文件内容：

1 1:2 2:3 3:3
2 1:5 2:8 3:9
1 1:7 2:6 3:7
1 1:3 2:2 3:1

注：这是LibSVM文件格式，通用格式为：行号 索引号:值 索引从1开始

import org.apache.spark.mllib.linalg.{Vector,Vectors}
import org.apache.spark.mllib.regression.LabeledPoint
import org.apache.spark._
import org.apache.spark.mllib.util.MLUtils

object testLabeledPoint2{
    def main(args:Array[String]){
        val conf = new SparkConf() //建立本地环境变量
            .setMaster("local")
            .setAppName("testLabeledPoint2")
        val sc = new SparkContext(conf)

        val mu = MLUtils.loadLibSVMFile(sc,"E:\\a.txt")
        mu.foreach(println)
    }
}

----------
(1.0,(3,[0,1,2],[2.0,3.0,3.0]))
(2.0,(3,[0,1,2],[5.0,8.0,9.0]))
(1.0,(3,[0,1,2],[7.0,6.0,7.0]))
(1.0,(3,[0,1,2],[3.0,2.0,1.0]))

本地矩阵

为了更多更快的使用矩阵运算进行数据处理，本地矩阵是很好的存储方法。

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

object testMatrix {
    def main(args: Array[String]): Unit = {
        val mx = Matrices.dense(2,3,Array(1,2,3,4,5,6)) //创建一个两行三列的矩阵，矩阵内容为123456
        println(mx)
    }
}
----------
1.0  3.0  5.0  
2.0  4.0  6.0  

分布式矩阵

一般来说分布式矩阵用来存储数据量非常大的数据集，其处理速度和效率与其存储格式息息相关。分布式矩阵有：行矩阵，带索引的行矩阵，坐标矩阵和块矩阵,主要看前三个格式。

行矩阵

行矩阵是最基本的一种矩阵类型。行矩阵是以行为基本方向的矩阵存储格式。

文件内容：

1 2 3
4 5 6

import org.apache.spark._
import org.apache.spark.mllib.linalg.{Vector,Vectors}
import org.apache.spark.mllib.linalg.distributed.RowMatrix

object testRowMatrix {
    def main(args: Array[String]): Unit = {
        val  conf = new SparkConf()
            .setMaster("local")
            .setAppName("testRowMatrix")
        val sc = new SparkContext(conf)
        val rdd = sc.textFile("E:\\a.txt")
            .map(_.split(" ")
            .map(_.toDouble))
            .map(line => Vectors.dense(line))
        val rm = new RowMatrix(rdd)
        println(rm.numRows())
        println(rm.numCols())
    }
}
----------
2
3

带索引的行矩阵

行矩阵无法对内容直接显示，但是为了方便调试，可以使用带索引的行矩阵。

import org.apache.spark._
import org.apache.spark.mllib.linalg.distributed.{IndexedRow,RowMatrix,IndexedRowMatrix}
import org.apache.spark.mllib.linalg.{Vectors,Vector}
object testIndexedRowMatrix {
    def main(args: Array[String]): Unit = {
        // 创建conf
        val conf = new SparkConf()
            .setMaster("local")
            .setAppName("testIndexecRowMatrix")
        // 实例化环境变量
        val sc = new SparkContext(conf)
        // 创建RDD文件路径
        val rdd = sc.textFile("e://a.txt")
            .map(_.split(" ")
            .map(_.toDouble))
            .map(line => Vectors.dense(line))          // 转化成向量存储
            .map((vd) => new IndexedRow(vd.size,vd))   // 转化格式
        val irm = new IndexedRowMatrix(rdd)
        println(irm.getClass)
        println(irm.rows.foreach(println))
    }
}

----------
class org.apache.spark.mllib.linalg.distributed.IndexedRowMatrix
IndexedRow(3,[1.0,2.0,3.0])
IndexedRow(3,[4.0,5.0,6.0])

坐标矩阵

坐标矩阵就是在带行索引的行矩阵上再加一个列索引。

import org.apache.spark._
import org.apache.spark.mllib.linalg.{Vector,Vectors}
import org.apache.spark.mllib.linalg.distributed.{CoordinateMatrix,MatrixEntry}
object testCoordinateRowMatrix {
    def main(args: Array[String]): Unit = {
        // 创建conf
        val conf = new SparkConf()
            .setMaster("local")
            .setAppName("testCoordinateRowMatrix")
        // 实例化环境变量
        val sc = new SparkContext(conf)
        // 创建RDD文件路径
        val rdd = sc.textFile("e://a.txt")
            .map(_.split(" ")
            .map(_.toDouble))
            // 转化成坐标格式
            .map(vue => (vue(0).toLong,vue(1).toLong,vue(2)))     
            // 转化成坐标矩阵格式
            .map(vue2 => new MatrixEntry(vue2 _1,vue2 _2,vue2 _3)) 
        val crm = new CoordinateMatrix(rdd)
        println(crm.entries.foreach(println))
    }
}

----------
MatrixEntry(1,2,3.0)
MatrixEntry(4,5,6.0)