Question

当我使用大型稀疏矩阵时，最好使用CCS，CRS等压缩矩阵。

我尝试使用ScalaNLP，la4j，colc来计算100,000 * 100,000稀疏矩阵。有一些问题。

Breeze（ScalaNLP / Scalala）
- 它为我提供了CSCMatrix类型，其大小可达100,000 * 100,000。
- 但问题是它正在开发中。
- 所以我们不能将CSCMatrix的元素产品与CSCMatrix一起计算，例如csc1 :* csc2。
- 并且您也无法相互添加CSCMatrix。
la4j
- 它有CCSMatrix和CRSMatrix。
- 但在创建（new CCSMatrixFactory）.createMatrix（100000,100000）时，会出现OutOfMemoryError。
- 矩阵应为零，因此不应使用大的内存空间。
COLC
- 它有SparseDoubleMatrix2D。
- 但是在创建像新的SparseDoubleMatrix2d（100000,100000）这样的矩阵时，它会说IllegalArgumentException：矩阵太大。

要计算大型稀疏矩阵，我可以使用哪个库？你能告诉我这个例子吗？

Answer 1

我对Breeze很好奇，所以我查看了源代码。它有点乱，因为运算符都是从某些println样式代码生成中发出的（！）......但我想出了这个：

import breeze.linalg.operators.{BinaryOp, OpMulScalar}

object CSCMatrixExtraOps {
  abstract class CSCMatrixCanMulM_M[@specialized (Int, Float, Long, Double) A]
    extends BinaryOp[CSCMatrix[A], CSCMatrix[A], OpMulScalar, CSCMatrix[A]] {

    protected def times(a: A, b: A): A

    protected def zeros  (rows: Int, cols: Int): CSCMatrix[A]
    protected def builder(rows: Int, cols: Int, sz: Int): CSCMatrix.Builder[A]

    final def apply(a: CSCMatrix[A], b: CSCMatrix[A]): CSCMatrix[A] = {
      val rows  = a.rows
      val cols  = a.cols
      require(rows == b.rows, "Matrices must have same number of rows!")
      require(cols == b.cols, "Matrices must have same number of cols!")

      if (cols == 0) return zeros(rows, cols)

      val res     = builder(rows, cols, math.min(a.activeSize, b.activeSize))
      var ci      = 0
      var acpStop = a.colPtrs(0)
      var bcpStop = b.colPtrs(0)
      while (ci < cols) {
        val ci1 = ci + 1
        var acp = acpStop
        var bcp = bcpStop
        acpStop = a.colPtrs(ci1)
        bcpStop = b.colPtrs(ci1)
        while (acp < acpStop && bcp < bcpStop) {
          val ari = a.rowIndices(acp)
          val bri = b.rowIndices(bcp)
          if (ari == bri) {
            val v = times(a.data(acp), b.data(bcp))
            res.add(ari, ci, v)
            acp += 1
            bcp += 1
          } else if (ari < bri) {
            acp += 1
          } else /* ari > bri */ {
            bcp += 1
          }
        }
        ci = ci1
      }

      res.result()
    }
  }

  implicit object CSCMatrixCanMulM_M_Int extends CSCMatrixCanMulM_M[Int] {
    protected def times(a: Int, b: Int) = a * b
    protected def zeros(rows: Int, cols: Int) = CSCMatrix.zeros(rows, cols)
    protected def builder(rows: Int, cols: Int, sz: Int) = 
      new CSCMatrix.Builder(rows, cols, sz)
  }

  implicit object CSCMatrixCanMulM_M_Double extends CSCMatrixCanMulM_M[Double] {
    protected def times(a: Double, b: Double) = a * b
    protected def zeros(rows: Int, cols: Int) = CSCMatrix.zeros(rows, cols)
    protected def builder(rows: Int, cols: Int, sz: Int) = 
      new CSCMatrix.Builder(rows, cols, sz)
  }
}

示例：

import breeze.linalg._ import CSCMatrixExtraOps._ val m1 = CSCMatrix((0, 0, 0), (0, 5, 0), (0, 0, 10), (0, 13, 0)) val m2 = CSCMatrix((0, 0, 0), (0, 5, 0), (0, 0, 10), (13, 0, 0)) (m1 :* m2).toDenseMatrix

结果：

0 0 0 0 25 0 0 0 100 0 0 0

Answer 2

我是la4j库的作者。我给你一些建议。因此，当您创建新的CRS / CCS矩阵时，la4j仅为其分配32个长度数组（它是默认的最小大小）。因此，它不会抛出OOM错误（我刚检查过它）：

Matrix a = Matrices.CRS_FACTORY.createMatrix(100000, 100000);

但是，最好使用公共构造函数：

Matrix a = new CCSMatrix(100000, 100000);

无论如何，如果仍然出现此错误，请尝试使用-Xmx1024m -Xms512m扩展堆大小。

你的意思是“矩阵应该是零，所以它不应该使用大的内存空间。”我不确定我是否理解正确。

BTW，使用la4j的最新版本：0.4.0。可能您发现的问题已由this pull-request修正。

我可以使用什么库来计算Java或Scala中的大型稀疏矩阵？

2 个答案: