5

大規模な疎行列を使用する場合は、CCS や CRS などの圧縮行列を使用することをお勧めします。

ScalaNLP、la4j、colc を使用して 100,000*100,000 疎行列を計算しようとしました。いくつかの問題があります。

  1. Breeze (ScalaNLP/Scala)

    • CSCMatrix100,000*100,000 のサイズを持つことができる型を与えてくれます。
    • しかし、問題はそれが開発中であるということです。
    • そのため、 のように の要素ごとの積を計算することはできませCSCMatrixん。CSCMatrixcsc1 :* csc2
    • また、CSCMatrix を相互に追加することもできません。

  2. la4j

    • CCSMatrix と CRSMatrix があります。
    • ただし、(new CCSMatrixFactory).createMatrix(100000, 100000) を作成すると、OutOfMemoryError が発生します。
    • 行列はゼロでなければならないため、大きなメモリ空間を使用しないでください。

  3. コルク

    • SparseDoubleMatrix2D があります。
    • しかし、新しい SparseDoubleMatrix2d(100000, 100000) のようなマトリックスを作成すると、IllegalArgumentException: マトリックスが大きすぎます。

大きな疎行列を計算するには、どのライブラリを使用できますか? 例を見せていただけますか？

4

2 に答える 2

3

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
于 2013-06-15T17:50:47.247 に答える