Spark MLlib 之 Vector向量深刻淺出

Spark MLlib裏面提供了幾種基本的數據類型，雖然大部分在調包的時候用不到，可是在本身寫算法的時候，仍是很須要瞭解的。MLlib支持單機版本的local vectors向量和martix矩陣,也支持集羣版本的matrix矩陣。他們背後使用的都是ScalaNLP中的Breeze。

更多內容參考個人大數據學習之路

Local Vector

local vector是一種索引是0開始的整數、內容爲double類型，存儲在單機上的向量。MLlib支持兩種矩陣，dense密集型和sparse稀疏型。一個dense類型的向量背後其實就是一個數組，而sparse向量背後則是兩個並行數組——索引數組和值數組。好比向量(1.0, 0.0, 3.0)既能夠用密集型向量表示爲[1.0, 0.0, 3.0]，也能夠用稀疏型向量表示爲(3, [0,2],[1.0,3.0])，其中3是數組的大小。

接口爲Vector，看源碼能夠看到它是用sealed修飾的，在scala裏面這種關鍵字修飾的trait在進行match的時候必須把全部的狀況都列出來，否則會報錯。至關於強制你考慮向量的時候，必須考慮它是dense型的，仍是sparse型的。

sealed trait Vector extends Serializable {
  def size: Int // 向量的大小
  def toArray: Array[Double] //轉換成普通的數組

  override def equals(other: Any): Boolean = { // 定義比較方法——感慨，原來這麼優秀的框架背後也用窮舉
    other match {
      case v2: Vector =>
        if (this.size != v2.size) return false
        (this, v2) match {
          case (s1: SparseVector, s2: SparseVector) =>
            Vectors.equals(s1.indices, s1.values, s2.indices, s2.values)
          case (s1: SparseVector, d1: DenseVector) =>
            Vectors.equals(s1.indices, s1.values, 0 until d1.size, d1.values)
          case (d1: DenseVector, s1: SparseVector) =>
            Vectors.equals(0 until d1.size, d1.values, s1.indices, s1.values)
          case (_, _) => util.Arrays.equals(this.toArray, v2.toArray)
        }
      case _ => false
    }
  }

  override def hashCode(): Int = { //好好領略hashcode的魅力
    var result: Int = 31 + size
    var nnz = 0
    this.foreachActive { (index, value) =>
      if (nnz < Vectors.MAX_HASH_NNZ) {
        if (value != 0) {
          result = 31 * result + index
          val bits = java.lang.Double.doubleToLongBits(value)
          result = 31 * result + (bits ^ (bits >>> 32)).toInt
          nnz += 1
        }
      } else {
        return result
      }
    }
    result
  }

  // 這裏面的BV實際上是breeze裏面的vector，import breeze.linalg.{DenseVector => BDV, SparseVector => BSV, Vector => BV}
  // 也就是說，mllib裏面的vector其實就是對breeze裏面的vector封裝了一層而已
  private[spark] def asBreeze: BV[Double]
  def apply(i: Int): Double = asBreeze(i)
  def copy: Vector = {
    throw new NotImplementedError(s"copy is not implemented for ${this.getClass}.")
  }
  def foreachActive(f: (Int, Double) => Unit): Unit
  def numActives: Int
  def numNonzeros: Int //零的個數
  def toSparse: SparseVector
  def toDense: DenseVector = new DenseVector(this.toArray) //建立Dense向量還真是簡單啊

  def compressed: Vector = {
    val nnz = numNonzeros
    // A dense vector needs 8 * size + 8 bytes, while a sparse vector needs 12 * nnz + 20 bytes.
    if (1.5 * (nnz + 1.0) < size) {
      toSparse
    } else {
      toDense
    }
  }

  def argmax: Int //返回裏面的最大值
}

Vector有兩種實現方式——DenseVector，和SparseVector。

import org.apache.spark.ml.linalg.{Vector,Vectors}
import org.apache.spark.sql.SparkSession

object DataTypes {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[*]").appName("tf-idf").getOrCreate()
    spark.sparkContext.setLogLevel("WARN")

    // 建立dense vector
    val dv: Vector = Vectors.dense(1.0, 0.0, 3.0)
    // 建立sparse vector
    val sv1: Vector = Vectors.sparse(3, Array(0,2), Array(1.0,3.0))
    val sv2: Vector = Vectors.sparse(3, Seq((0, 1.0), (2,3.0)))
  }
}

其中sparse vector有兩種建立方式，第一種是傳入三個參數：向量大小、索引數組、索引數組對應的值數組；第二種方式是傳入兩個參數：向量大小、由索引和值組成的鍵值對數組。

另外這個Vectors不單單有建立dense和sparse的方法，還有幾個有用的功能，好比norm範數和sqdist距離。

val norm1Vec = Vectors.dense(1.0,-1.0,2.0)
// 第一範數，就是絕對值相加
println(Vectors.norm(norm1Vec,1)) // 4.0
// 第二番薯，就是平方和開根號
println(Vectors.norm(norm1Vec,2)) // 2.449489742783178
// 無限範數
println(Vectors.norm(norm1Vec,1000)) //2.0

val sq1 = Vectors.dense(1.0, 2.0, 3.0)
val sq2 = Vectors.dense(2.0, 4.0, 6.0)
println(Vectors.sqdist(sq1, sq2)) // (2-1)^2 + (4-2)^2 + (6-3)^2 = 14

經過上面簡單的一個Vector，仍是能學到很多東西的。

好比sealed關鍵字的使用，以及工廠方法：

object xxxFactory{
    def x1: XXX
    def x2: XXX
    ...
}
trait XXX {}
object X1 extends XXX {}
object X2 extends XXX {}

Labeled Point 有標籤的向量

這種labeled point其實內部也是一個vector，多是dense也多是sparse，不過多了一個標籤列。在ML裏面，labeled point一般用於有監督算法。這個label是double類型的，這樣既能夠用於迴歸算法，也能夠用於分類。在二分類中，Label不是0就是1；在多分類中label可能從0開始，1，2，3，4....

使用的時候很簡單，直接new就能夠了：

// Create a labeled point with a positive label and a dense feature vector.
val pos = LabeledPoint(1.0, Vectors.dense(1.0, 0.0, 3.0))

// Create a labeled point with a negative label and a sparse feature vector.
val neg = LabeledPoint(0.0, Vectors.sparse(3, Array(0, 2), Array(1.0, 3.0)))

通常在準備訓練集數據的時候，數據都是稀疏型的。MMLib支持在SVM和Liner線性迴歸中直接讀取訓練數據，可是須要知足下面的格式：

label index1:value1 index2:value2 ...

好比:

val examples: RDD[LabeledPoint] = MLUtils.loadLibSVMFile(sc, "data/mllib/sample_libsvm_data.txt")