PROSAGA码农传奇-分布式计算-Spark分布式矩阵乘法和伪逆计算

0# 晴天？霹雳 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <P>
    这是反向的实现。
  </p>
   <pre>
    <code>
      import org.apache.spark.mllib.linalg.{Vectors,Vector,Matrix,SingularValueDecomposition,DenseMatrix,DenseVector}
import org.apache.spark.mllib.linalg.distributed.RowMatrix

def computeInverse(X: RowMatrix): DenseMatrix = {
  val nCoef = X.numCols.toInt
  val svd = X.computeSVD(nCoef, computeU = true)
  if (svd.s.size < nCoef) {
    sys.error(s"RowMatrix.computeInverse called on singular matrix.")
  }

// Create the inv diagonal matrix from S 
  val invS = DenseMatrix.diag(new DenseVector(svd.s.toArray.map(x => math.pow(x,-1))))

// U cannot be a RowMatrix
  val U = new DenseMatrix(svd.U.numRows().toInt,svd.U.numCols().toInt,svd.U.rows.collect.flatMap(x => x.toArray))

// If you could make V distributed, then this may be better. However its alreadly local...so maybe this is fine.
  val V = svd.V
  // inv(X) = V*inv(S)*transpose(U)  --- the U is already transposed.
  (V.multiply(invS)).multiply(U)
  }

</code>
  </pre>
</DIV>

1# 晴天 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <P>
    的<strong>
      矩阵乘法
    </强>
     更容易：有几个
     <code>
      Matrix
    </code>
     用a实现
     <code>
      multiply
    </code>
     包中的方法
     <code>
      org.apache.spark.mllib.linalg
    </code>
     和
     <code>
      org.apache.spark.mllib.linalg.distributed
    </code>
    。挑选最符合您需求的产品。
  </p>
  <P>
    我没见过
    的<strong>
      （伪）逆
    </强>
     Spark API中的任何位置。但
     <code>
      RowMatrix
    </code>
     能够计算出来
    <EM>
      奇异值分解
    </EM>
     它可以用来计算矩阵的逆。这是一个非常天真的实现，受到启发
    <a href="https://math.stackexchange.com/questions/458404/how-can-we-compute-pseudoinverse-for-any-matrix">
      我们如何计算任何矩阵的伪逆
    </A>
     （警告：2x2矩阵的尺寸是硬编码的）：
  </p>
   <pre class="lang-scala prettyprint-override">
    <code>
      val m = new RowMatrix(sc.parallelize(Seq(Vectors.dense(4, 3), Vectors.dense(3, 2))))
val svd = m.computeSVD(2, true)
val v = svd.V
val sInvArray = svd.s.toArray.toList.map(x => 1.0 / x).toArray
val sInverse = new DenseMatrix(2, 2, Matrices.diag(Vectors.dense(sInvArray)).toArray)
val uArray = svd.U.rows.collect.toList.map(_.toArray.toList).flatten.toArray
val uTranspose = new DenseMatrix(2, 2, uArray) // already transposed because DenseMatrix is column-major
val inverse = v.multiply(sInverse).multiply(uTranspose)
  // -1.9999999999998297  2.999999999999767    
  // 2.9999999999997637   -3.9999999999996767

</code>
  </pre>
  <P>
    不幸的是，从Matrix到Array等的大量转换是必要的。如果您需要完全分布式实现，请尝试使用
     <code>
      DistributedMatrix
    </code>
     代替
     <code>
      DenseMatrix
    </code>
    。如果没有，可以在这里使用Breeze。
  </p>
</DIV>

2# Jacob | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <P>
    要计算非平方矩阵的伪逆，您需要能够计算转置（简单）和矩阵逆（其他已提供该功能）。根据是否，有两种不同的计算方法
     <code>
      M
    </code>
     具有完整的列级别或完整的行级别。
  </p>
  <P>
    全列等级意味着矩阵的列是线性独立的，这要求列数小于或等于行数。 （在病态情况下，m> = n的mxn矩阵可能仍然没有完整的列级别，但我们将忽略统计不可能性。如果在您的情况下有可能，下面的矩阵求逆步骤将失败。）完整列等级，伪逆是
  </p>
   <pre>
    <code>
      M^+ = (M^T M)^{-1} M^T

</code>
  </pre>
  <P>
    哪里
     <code>
      M^T
    </code>
     是的转置
     <code>
      M
    </code>
    。矩阵乘法
     <code>
      M^T
    </code>
     通过
     <code>
      M
    </code>
    ，然后取逆，然后矩阵乘以
     <code>
      M^T
    </code>
     再次。 （我假设
     <code>
      M
    </code>
     有实数的条目;如果条目是复数，则还必须采用复数共轭。）
  </p>
  <P>
    快速检查以确保您正确计算了psuedo-inverse是检查
     <code>
      M^+ M
    </code>
    。它应该是单位矩阵（最多浮点错误）。
  </p>
  <P>
    另一方面，如果
     <code>
      M
    </code>
     换句话说，有完整的排名
     <code>
      M
    </code>
     mx是m <= n，伪逆是
  </p>
   <pre>
    <code>
      M^+ = M^T (M M^T)^{-1}

</code>
  </pre>
  <P>
    要检查在这种情况下是否有正确的伪逆，请与原始矩阵正确相乘：
     <code>
      M M^+
    </code>
    。这应该等于单位矩阵，直到浮点错误。
  </p>
</DIV>