相关性系数

  计算两个数据集的相关性是统计中的常用操作。在MLlib中提供了计算多个数据集两两相关的方法。目前支持的相关性方法有皮尔森(Pearson)相关和斯皮尔曼(Spearman)相关。

  Statistics提供方法计算数据集的相关性。根据输入的类型，两个RDD[Double]或者一个RDD[Vector]，输出将会是一个Double值或者相关性矩阵。下面是一个应用的例子。

  1. import org.apache.spark.SparkContext
  2. import org.apache.spark.mllib.linalg._
  3. import org.apache.spark.mllib.stat.Statistics
  4. val sc: SparkContext = ...
  5. val seriesX: RDD[Double] = ... // a series
  6. val seriesY: RDD[Double] = ... // must have the same number of partitions and cardinality as seriesX
  7. // compute the correlation using Pearson's method. Enter "spearman" for Spearman's method. If a 
  8. // method is not specified, Pearson's method will be used by default. 
  9. val correlation: Double = Statistics.corr(seriesX, seriesY, "pearson")
  10. val data: RDD[Vector] = ... // note that each Vector is a row and not a column
  11. // calculate the correlation matrix using Pearson's method. Use "spearman" for Spearman's method.
  12. // If a method is not specified, Pearson's method will be used by default. 
  13. val correlMatrix: Matrix = Statistics.corr(data, "pearson")

  这个例子中我们看到，计算相关性的入口函数是Statistics.corr，当输入的数据集是两个RDD[Double]时，它的实际实现是Correlations.corr，当输入数据集是RDD[Vector]时，它的实际实现是Correlations.corrMatrix。
下文会分别分析这两个函数。

  1. def corr(x: RDD[Double],
  2.        y: RDD[Double],
  3.        method: String = CorrelationNames.defaultCorrName): Double = {
  4.     val correlation = getCorrelationFromName(method)
  5.     correlation.computeCorrelation(x, y)
  6.   }
  7. def corrMatrix(X: RDD[Vector],
  8.       method: String = CorrelationNames.defaultCorrName): Matrix = {
  9.     val correlation = getCorrelationFromName(method)
  10.     correlation.computeCorrelationMatrix(X)
  11.   }

  这两个函数的第一步就是获得对应方法名的相关性方法的实现对象。并且如果输入数据集是两个RDD[Double]，MLlib会将其统一转换为RDD[Vector]进行处理。

  1. def computeCorrelationWithMatrixImpl(x: RDD[Double], y: RDD[Double]): Double = {
  2.     val mat: RDD[Vector] = x.zip(y).map { case (xi, yi) => new DenseVector(Array(xi, yi)) }
  3.     computeCorrelationMatrix(mat)(0, 1)
  4.   }

  不同的相关性方法，computeCorrelationMatrix的实现不同。下面分别介绍皮尔森相关与斯皮尔曼相关的实现。

1 皮尔森相关系数

  皮尔森相关系数也叫皮尔森积差相关系数，是用来反映两个变量相似程度的统计量。或者说可以用来计算两个向量的相似度（在基于向量空间模型的文本分类、用户喜好推荐系统中都有应用）。皮尔森相关系数计算公式如下：

2.1

  当两个变量的线性关系增强时，相关系数趋于1或-1。正相关时趋于1，负相关时趋于-1。当两个变量独立时相关系统为0，但反之不成立。当Y和X服从联合正态分布时，其相互独立和不相关是等价的。
皮尔森相关系数的计算通过下面代码实现。

  1. override def computeCorrelationMatrix(X: RDD[Vector]): Matrix = {
  2.     val rowMatrix = new RowMatrix(X)
  3.     //计算协方差矩阵
  4.     val cov = rowMatrix.computeCovariance()
  5.     computeCorrelationMatrixFromCovariance(cov)
  6.   }
  7. def computeCorrelationMatrixFromCovariance(covarianceMatrix: Matrix): Matrix = {
  8.     val cov = covarianceMatrix.toBreeze.asInstanceOf[BDM[Double]]
  9.     val n = cov.cols
  10.     // 计算对角元素的标准差
  11.     var i = 0
  12.     while (i < n) {
  13.       cov(i, i) = if (closeToZero(cov(i, i))) 0.0 else math.sqrt(cov(i, i))
  14.       i +=1
  15.     }
  16.     // Loop through columns since cov is column major
  17.     var j = 0
  18.     var sigma = 0.0
  19.     var containNaN = false
  20.     while (j < n) {
  21.       sigma = cov(j, j)
  22.       i = 0
  23.       while (i < j) {
  24.         val corr = if (sigma == 0.0 || cov(i, i) == 0.0) {
  25.           containNaN = true
  26.           Double.NaN
  27.         } else {
  28.           //根据上文的公式计算，即cov(x,y)/(sigma_x * sigma_y)
  29.           cov(i, j) / (sigma * cov(i, i))
  30.         }
  31.         cov(i, j) = corr
  32.         cov(j, i) = corr
  33.         i += 1
  34.       }
  35.       j += 1
  36.     }
  37.     // put 1.0 on the diagonals
  38.     i = 0
  39.     while (i < n) {
  40.       cov(i, i) = 1.0
  41.       i +=1
  42.     }
  43.     Matrices.fromBreeze(cov)
  44.   }

2 斯皮尔曼相关系数

  使用皮尔森线性相关系数有2个局限：首先，必须假设数据是成对地从正态分布中取得的；其次，数据至少在逻辑范围内是等距的。对不服从正态分布的资料不符合使用矩相关系数来描述关联性。
此时可采用秩相关（rank correlation），也称等级相关，来描述两个变量之间的关联程度与方向。斯皮尔曼秩相关系数就是其中一种。

  斯皮尔曼秩相关系数定义为排序变量(ranked variables)之间的皮尔逊相关系数。对于大小为n的样本集，将原始的数据X_i和Y_i转换成排序变量rgX_i和rgY_i，然后按照皮尔森相关系数的计算公式进行计算。

2.2

  下面的代码将原始数据转换成了排序数据。

  1. override def computeCorrelationMatrix(X: RDD[Vector]): Matrix = {
  2.     // ((columnIndex, value), rowUid)
  3.     //使用zipWithUniqueId产生的rowUid全局唯一
  4.     val colBased = X.zipWithUniqueId().flatMap { case (vec, uid) =>
  5.       vec.toArray.view.zipWithIndex.map { case (v, j) =>
  6.         ((j, v), uid)
  7.       }
  8.     }
  9.     // 通过(columnIndex, value)全局排序，排序的好处是使下面只需迭代一次
  10.     val sorted = colBased.sortByKey()
  11.     // 分配全局的ranks (using average ranks for tied values)
  12.     val globalRanks = sorted.zipWithIndex().mapPartitions { iter =>
  13.       var preCol = -1
  14.       var preVal = Double.NaN
  15.       var startRank = -1.0
  16.       var cachedUids = ArrayBuffer.empty[Long]
  17.       val flush: () => Iterable[(Long, (Int, Double))] = () => {
  18.         val averageRank = startRank + (cachedUids.size - 1) / 2.0
  19.         val output = cachedUids.map { uid =>
  20.           (uid, (preCol, averageRank))
  21.         }
  22.         cachedUids.clear()
  23.         output
  24.       }
  25.       iter.flatMap { case (((j, v), uid), rank) =>
  26.         // 如果有新的值或者cachedUids过大, 调用flush
  27.         if (j != preCol || v != preVal || cachedUids.size >= 10000000) {
  28.           val output = flush()
  29.           preCol = j
  30.           preVal = v
  31.           startRank = rank
  32.           cachedUids += uid
  33.           output
  34.         } else {
  35.           cachedUids += uid
  36.           Iterator.empty
  37.         }
  38.       } ++ flush()
  39.     } 
  40.    //使用rank值代替原来的值
  41.    val groupedRanks = globalRanks.groupByKey().map { case (uid, iter) =>
  42.        // 根据列索引排序
  43.        Vectors.dense(iter.toSeq.sortBy(_._1).map(_._2).toArray)
  44.    }

  在每个分区内部，对于列索引相同且值相同的数据对，我们为其分配平均rank值。平均rank的计算方式如下面公式所示：

2.3

  其中rank_start表示列索引相同且值相同的数据对在分区中第一次出现时的索引位置，n表示列索引相同且值相同的数据对出现的次数。

3 参考文献

【1】Pearson product-moment correlation coefficient

【2】Spearman’s rank correlation coefficient

【3】相关性检验—Spearman秩相关系数和皮尔森相关系数