Make column matrix directly

apps/src/main/scala/org/clulab/scala_transformers/apps/TokenClassifierTimerApp.scala

@@ -90,7 +90,7 @@ object TokenClassifierTimerApp extends App {
     }
   }
 
-  val log = true
+  val verbose = false
   val fileName = args.lift(0).getOrElse("../corpora/sentences/sentences.txt")
   val untimedTokenClassifier = TokenClassifier.fromFiles("../roberta-base-mtl/avg_export")
   val tokenClassifier = new TimedTokenClassifier(untimedTokenClassifier)
@@ -110,7 +110,7 @@ object TokenClassifierTimerApp extends App {
         val words = line.split(" ").toSeq
         val allLabelSeqs = tokenClassifier.predictWithScores(words)
 
-        if (log) {
+        if (verbose) {
           println(s"Words: ${words.mkString(", ")}")
           for (layer <- allLabelSeqs) {
             val words = layer.map(_.head) // Collapse the next layer by just taking the head.

encoder/src/main/scala/org/clulab/scala_transformers/encoder/BreezeExamples.scala

@@ -1,10 +1,10 @@
 package org.clulab.scala_transformers.encoder
 
-import breeze.linalg._ 
-import BreezeUtils._
+import breeze.linalg._
+import org.clulab.scala_transformers.encoder.math.BreezeMath
 
 object BreezeExamples extends App {
-  val m = mkRowMatrix[Float](Array(Array(1f, 2f), Array(3f, 4f)))
+  val m = BreezeMath.mkRowMatrix(Array(Array(1f, 2f), Array(3f, 4f)))
   println(m)
 
   println("Row 0: " + m(0, ::))

encoder/src/main/scala/org/clulab/scala_transformers/encoder/LinearLayer.scala

@@ -88,7 +88,7 @@ class LinearLayer(
       val headHiddenState = Math.row(sentenceHiddenStates, headAbsolutePosition)
 
       // vector concatenation in Breeze operates over vertical vectors, hence the transposing here
-      val concatState = Math.cat(modHiddenState, headHiddenState)
+      val concatState = Math.horcat(modHiddenState, headHiddenState)
       // row i in the concatenated matrix contains the embedding of modifier i and its head
       Math.inplaceMatrixAddition(concatMatrix, i, concatState)
     }
@@ -121,7 +121,7 @@ class LinearLayer(
 
     // concatenation of the modifier and head embeddings
     // vector concatenation in Breeze operates over vertical vectors, hence the transposing here
-    val concatState = Math.cat(modHiddenState, headHiddenState)
+    val concatState = Math.horcat(modHiddenState, headHiddenState)
     Math.inplaceMatrixAddition(concatMatrix, 0, concatState)
     concatMatrix
   }

encoder/src/main/scala/org/clulab/scala_transformers/encoder/LinearLayerFactory.scala

@@ -32,7 +32,7 @@ abstract class LinearLayerFactory(val linearLayerLayout: LinearLayerLayout) exte
     if (exists(place)) {
       val values = sourceFloatVector(newSource(place))
       // the bias is a column vector
-      val biases = Math.mkVector(values)
+      val biases = Math.mkColVector(values)
 
       logger.info(s"Found biases with dimension ${Math.length(biases)}")
       Some(biases)

encoder/src/main/scala/org/clulab/scala_transformers/encoder/math/BreezeMath.scala

@@ -2,33 +2,30 @@ package org.clulab.scala_transformers.encoder.math
 
 import ai.onnxruntime.OrtSession.Result
 import breeze.linalg.{DenseMatrix, DenseVector, Transpose, `*`, argmax => BreezeArgmax}
-import org.clulab.scala_transformers.encoder.BreezeUtils
 
 object BreezeMath extends Math {
   type MathValue = Float
+  type MathColMatrix = DenseMatrix[MathValue]
   type MathRowMatrix = DenseMatrix[MathValue]
   type MathColVector = DenseVector[MathValue]
   type MathRowVector = Transpose[DenseVector[MathValue]]
 
   def fromResult(result: Result): Array[MathRowMatrix] = {
     val array = result.get(0).getValue.asInstanceOf[Array[Array[Array[Float]]]]
-    val outputs = array.map(BreezeUtils.mkRowMatrix(_))
+    val outputs = array.map(mkRowMatrix(_))
 
     outputs
   }
 
   def argmax(rowVector: MathRowVector): Int = {
-    val bestIndex = BreezeArgmax(rowVector.t)
-
-    bestIndex
+    BreezeArgmax(rowVector)
   }
 
   def inplaceMatrixAddition(matrix: MathRowMatrix, colVector: MathColVector): Unit = {
     matrix(*, ::) :+= colVector
   }
 
   def inplaceMatrixAddition(matrix: MathRowMatrix, rowIndex: Int, rowVector: MathRowVector): Unit = {
-
     matrix(rowIndex, ::) :+= rowVector
   }
 
@@ -64,7 +61,7 @@ object BreezeMath extends Math {
     matrix(index, ::)
   }
 
-  def cat(leftRowVector: MathRowVector, rightRowVector: MathRowVector): MathRowVector = {
+  def horcat(leftRowVector: MathRowVector, rightRowVector: MathRowVector): MathRowVector = {
     DenseVector.vertcat(leftRowVector.t, rightRowVector.t).t
   }
 
@@ -77,10 +74,28 @@ object BreezeMath extends Math {
   }
 
   def mkRowMatrix(values: Array[Array[MathValue]]): MathRowMatrix = {
-    BreezeUtils.mkRowMatrix(values)
+    val rows = values.length
+    val cols = values.head.length
+    val denseMatrix = new DenseMatrix[Float](rows, cols)
+
+    for (row <- 0 until rows)
+      for (col <- 0 until cols)
+        denseMatrix(row, col) = values(row)(col)
+    denseMatrix
+  }
+
+  def mkColMatrix(values: Array[Array[MathValue]]): MathColMatrix = {
+    val rows = values.length
+    val cols = values.head.length
+    val denseMatrix = new DenseMatrix[Float](cols, rows)
+
+    for (row <- 0 until rows)
+      for (col <- 0 until cols)
+        denseMatrix(col, row) = values(row)(col)
+    denseMatrix
   }
 
-  def mkVector(values: Array[MathValue]): MathColVector = {
+  def mkColVector(values: Array[MathValue]): MathColVector = {
     DenseVector(values)
   }
 }

encoder/src/main/scala/org/clulab/scala_transformers/encoder/math/EjmlMath.scala

@@ -6,6 +6,7 @@ import org.ejml.simple.SimpleMatrix
 
 object EjmlMath extends Math {
   type MathValue = Float
+  type MathColMatrix = FMatrixRMaj
   type MathRowMatrix = FMatrixRMaj
   type MathColVector = FMatrixRMaj
   type MathRowVector = FMatrixRMaj
@@ -111,7 +112,7 @@ object EjmlMath extends Math {
     result
   }
 
-  def cat(leftRowVector: MathRowVector, rightRowVector: MathRowVector): MathRowVector = {
+  def horcat(leftRowVector: MathRowVector, rightRowVector: MathRowVector): MathRowVector = {
     assert(isRowVector(leftRowVector))
     assert(isRowVector(rightRowVector))
     val leftSimple = SimpleMatrix.wrap(leftRowVector)
@@ -138,7 +139,18 @@ object EjmlMath extends Math {
     new FMatrixRMaj(values)
   }
 
-  def mkVector(values: Array[MathValue]): MathColVector = {
+  def mkColMatrix(values: Array[Array[MathValue]]): MathColMatrix = {
+    val rows = values.length
+    val cols = values.head.length
+    val matrix = new FMatrixRMaj(cols, rows)
+
+    for (row <- 0 until rows)
+      for (col <- 0 until cols)
+        matrix.set(col, row, values(row)(col))
+    matrix
+  }
+
+  def mkColVector(values: Array[MathValue]): MathColVector = {
     val result = new FMatrixRMaj(values)
 
     assert(isColVector(result))

encoder/src/main/scala/org/clulab/scala_transformers/encoder/math/Math.scala

@@ -20,9 +20,13 @@ trait Math {
   def vertcat(leftColVector: MathColVector, rightColVector: MathColVector): MathColVector
   def zeros(rows: Int, cols: Int): MathRowMatrix
   def row(matrix: MathRowMatrix, index: Int): MathRowVector
-  def cat(leftRowVector: MathRowVector, rightRowVector: MathRowVector): MathRowVector
+  def horcat(leftRowVector: MathRowVector, rightRowVector: MathRowVector): MathRowVector
   def toArray(rowVector: MathRowVector): Array[MathValue]
   def get(rowVector: MathRowVector, index: Int): MathValue
   def mkRowMatrix(values: Array[Array[MathValue]]): MathRowMatrix
-  def mkVector(values: Array[MathValue]): MathColVector
+
+  // For this, the array is specified in column-major order,
+  // but it should be converted to the normal representation.
+  def mkColMatrix(values: Array[Array[MathValue]]): MathRowMatrix
+  def mkColVector(values: Array[MathValue]): MathColVector
 }

encoder/src/main/scala/org/clulab/scala_transformers/encoder/math/Mathematics.scala

@@ -2,8 +2,8 @@ package org.clulab.scala_transformers.encoder.math
 
 object Mathematics {
   // Pick one of these.
-//  val Math = BreezeMath // This takes care of the companion object.
-  val Math = EjmlMath
+  val Math = BreezeMath // This takes care of the companion object.
+//  val Math = EjmlMath
 //  val Math = OnnxMath
 
   type MathMatrix = Math.MathRowMatrix

encoder/src/main/scala/org/clulab/scala_transformers/encoder/math/OnnxMath.scala

@@ -65,7 +65,7 @@ object OnnxMath extends Math {
     ???
   }
 
-  def cat(left: OnnxTensor, right: OnnxTensor): OnnxTensor = {
+  def horcat(left: OnnxTensor, right: OnnxTensor): OnnxTensor = {
     ???
   }
 
@@ -82,7 +82,11 @@ object OnnxMath extends Math {
     OnnxTensor.createTensor(ortEnvironment, values)
   }
 
-  def mkVector(values: Array[Float]): OnnxTensor = {
+  def mkColMatrix(values: Array[Array[Float]]): OnnxTensor = {
+    ???
+  }
+
+  def mkColVector(values: Array[Float]): OnnxTensor = {
     OnnxTensor.createTensor(ortEnvironment, values)
   }
 }

encoder/src/test/scala/org/clulab/scala_transformers/encoder/math/BreezeMathTest.scala

@@ -8,7 +8,7 @@ class BreezeMathTest extends Test {
 
   it should "argmax" in {
     val values = Array(1f, 3f, 2f)
-    val vector = BreezeMath.mkVector(values).t
+    val vector = BreezeMath.mkColVector(values).t
     val expectedResult = 1
     val actualResult = BreezeMath.argmax(vector)
 
@@ -22,7 +22,7 @@ class BreezeMathTest extends Test {
     )
     val matrix = BreezeMath.mkRowMatrix(matrixValues)
     val vectorValues = Array(1f, 2f, 3f)
-    val vector = BreezeMath.mkVector(vectorValues)
+    val vector = BreezeMath.mkColVector(vectorValues)
     val expectedResult = Array(
       Array(2f, 4f, 6f),
       Array(3f, 6f, 9f)
@@ -44,7 +44,7 @@ class BreezeMathTest extends Test {
     )
     val matrix = BreezeMath.mkRowMatrix(matrixValues)
     val vectorValues = Array(1f, 2f, 3f)
-    val vector = BreezeMath.mkVector(vectorValues).t
+    val vector = BreezeMath.mkColVector(vectorValues).t
     val expectedResult = Array(
       Array(1f, 2f, 3f),
       Array(3f, 6f, 9f)
@@ -110,7 +110,7 @@ class BreezeMathTest extends Test {
 
   it should "length" in {
     val values = Array(1f, 2f, 3f)
-    val vector = BreezeMath.mkVector(values)
+    val vector = BreezeMath.mkColVector(values)
     val expectedResult = 3
     val actualResult = BreezeMath.length(vector)
 
@@ -140,8 +140,8 @@ class BreezeMathTest extends Test {
   it should "vertcat" in {
     val leftVectorValues = Array(1f, 2f, 3f)
     val rightVectorValues = Array(2f, 4f, 6f)
-    val leftVector = BreezeMath.mkVector(leftVectorValues)
-    val rightVector = BreezeMath.mkVector(rightVectorValues)
+    val leftVector = BreezeMath.mkColVector(leftVectorValues)
+    val rightVector = BreezeMath.mkColVector(rightVectorValues)
     val expectedResult = Array(1f, 2f, 3f, 2f, 4f, 6f)
     val actualResult = BreezeMath.vertcat(leftVector, rightVector)
 
@@ -182,10 +182,10 @@ class BreezeMathTest extends Test {
   it should "cat" in {
     val leftVectorValues = Array(1f, 2f, 3f)
     val rightVectorValues = Array(2f, 4f, 6f)
-    val leftVector = BreezeMath.mkVector(leftVectorValues).t
-    val rightVector = BreezeMath.mkVector(rightVectorValues).t
+    val leftVector = BreezeMath.mkColVector(leftVectorValues).t
+    val rightVector = BreezeMath.mkColVector(rightVectorValues).t
     val expectedResult = Array(1f, 2f, 3f, 2f, 4f, 6f)
-    val actualResult = BreezeMath.cat(leftVector, rightVector)
+    val actualResult = BreezeMath.horcat(leftVector, rightVector)
 
     expectedResult.zipWithIndex.foreach { case (expectedValue, index) =>
       actualResult(index) should be(expectedValue)
@@ -194,7 +194,7 @@ class BreezeMathTest extends Test {
 
   it should "toArray" in {
     val values = Array(1f, 2f, 3f)
-    val vector = BreezeMath.mkVector(values).t
+    val vector = BreezeMath.mkColVector(values).t
     val expectedResult = values
     val actualResult = BreezeMath.toArray(vector)
 
@@ -205,33 +205,50 @@ class BreezeMathTest extends Test {
 
   it should "get" in {
     val values = Array(1f, 2f, 3f)
-    val vector = BreezeMath.mkVector(values).t
+    val vector = BreezeMath.mkColVector(values).t
     val expectedResult = 2f
     val actualResult = BreezeMath.get(vector, 1)
 
     actualResult should be (expectedResult)
   }
 
   it should "mkRowMatrix" in {
-    val values = Array(
+    val matrix = Array(
       Array(1f, 2f, 3f),
       Array(2f, 4f, 6f)
     )
-    val matrix = BreezeMath.mkRowMatrix(values)
-    val expectedResult = "1.0  2.0  3.0  \n2.0  4.0  6.0  "
-    val actualResult = matrix.toString
+    val expectedResult = matrix
+    val actualResult = BreezeMath.mkRowMatrix(matrix)
 
-    actualResult should be (expectedResult)
-    values.zipWithIndex.foreach { case (values, rowIndex) =>
-      values.zipWithIndex.foreach { case (value, colIndex) =>
-        matrix(rowIndex, colIndex) should be (value)
+    expectedResult.zipWithIndex.foreach { case (expectedValues, rowIndex) =>
+      expectedValues.zipWithIndex.foreach { case (expectedValue, colIndex) =>
+        actualResult(rowIndex, colIndex) should be (expectedValue)
+      }
+    }
+  }
+
+  it should "mkColMatrix" in {
+    val matrix = Array(
+      Array(1f, 2f, 3f),
+      Array(2f, 4f, 6f)
+    )
+    val expectedResult = Array(
+      Array(1f, 2f),
+      Array(2f, 4f),
+      Array(3f, 6f)
+    )
+    val actualResult = BreezeMath.mkColMatrix(matrix)
+
+    expectedResult.zipWithIndex.foreach { case (expectedValues, rowIndex) =>
+      expectedValues.zipWithIndex.foreach { case (expectedValue, colIndex) =>
+        actualResult(rowIndex, colIndex) should be (expectedValue)
       }
     }
   }
 
   it should "mkVector" in {
     val values = Array(1f, 2f, 3f)
-    val vector = BreezeMath.mkVector(values)
+    val vector = BreezeMath.mkColVector(values)
     val expectedResult = "DenseVector(1.0, 2.0, 3.0)"
     val actualResult = vector.toString
 

encoder/src/test/scala/org/clulab/scala_transformers/encoder/math/EjmlMathTest.scala

@@ -7,8 +7,8 @@ class EjmlMathTest extends Test {
   behavior of "Math"
 
   it should "argmax" in {
-    val values = Array(1f, 3f, 2f)
-    val vector = EjmlMath.t(EjmlMath.mkVector(values))
+    val vectorValues = Array(1f, 3f, 2f)
+    val vector = EjmlMath.t(EjmlMath.mkColVector(vectorValues))
     val expectedResult = 1
     val actualResult = EjmlMath.argmax(vector)
 
@@ -22,7 +22,7 @@ class EjmlMathTest extends Test {
     )
     val matrix = EjmlMath.mkRowMatrix(matrixValues)
     val vectorValues = Array(1f, 2f, 3f)
-    val vector = EjmlMath.mkVector(vectorValues)
+    val vector = EjmlMath.mkColVector(vectorValues)
     val expectedResult = Array(
       Array(2f, 4f, 6f),
       Array(3f, 6f, 9f)
@@ -44,7 +44,7 @@ class EjmlMathTest extends Test {
     )
     val matrix = EjmlMath.mkRowMatrix(matrixValues)
     val vectorValues = Array(1f, 2f, 3f)
-    val vector = EjmlMath.t(EjmlMath.mkVector(vectorValues))
+    val vector = EjmlMath.t(EjmlMath.mkColVector(vectorValues))
     val expectedResult = Array(
       Array(1f, 2f, 3f),
       Array(3f, 6f, 9f)
@@ -109,8 +109,8 @@ class EjmlMathTest extends Test {
   }
 
   it should "length" in {
-    val values = Array(1f, 2f, 3f)
-    val vector = EjmlMath.mkVector(values)
+    val vectorValues = Array(1f, 2f, 3f)
+    val vector = EjmlMath.mkColVector(vectorValues)
     val expectedResult = 3
     val actualResult = EjmlMath.length(vector)
 
@@ -140,8 +140,8 @@ class EjmlMathTest extends Test {
   it should "vertcat" in {
     val leftVectorValues = Array(1f, 2f, 3f)
     val rightVectorValues = Array(2f, 4f, 6f)
-    val leftVector = EjmlMath.mkVector(leftVectorValues)
-    val rightVector = EjmlMath.mkVector(rightVectorValues)
+    val leftVector = EjmlMath.mkColVector(leftVectorValues)
+    val rightVector = EjmlMath.mkColVector(rightVectorValues)
     val expectedResult = Array(1f, 2f, 3f, 2f, 4f, 6f)
     val actualResult = EjmlMath.vertcat(leftVector, rightVector)
 
@@ -182,20 +182,20 @@ class EjmlMathTest extends Test {
   it should "cat" in {
     val leftVectorValues = Array(1f, 2f, 3f)
     val rightVectorValues = Array(2f, 4f, 6f)
-    val leftVector = EjmlMath.t(EjmlMath.mkVector(leftVectorValues))
-    val rightVector = EjmlMath.t(EjmlMath.mkVector(rightVectorValues))
+    val leftVector = EjmlMath.t(EjmlMath.mkColVector(leftVectorValues))
+    val rightVector = EjmlMath.t(EjmlMath.mkColVector(rightVectorValues))
     val expectedResult = Array(1f, 2f, 3f, 2f, 4f, 6f)
-    val actualResult = EjmlMath.cat(leftVector, rightVector)
+    val actualResult = EjmlMath.horcat(leftVector, rightVector)
 
     expectedResult.zipWithIndex.foreach { case (expectedValue, index) =>
       actualResult.get(index) should be(expectedValue)
     }
   }
 
   it should "toArray" in {
-    val values = Array(1f, 2f, 3f)
-    val vector = EjmlMath.t(EjmlMath.mkVector(values))
-    val expectedResult = values
+    val vectorValues = Array(1f, 2f, 3f)
+    val vector = EjmlMath.t(EjmlMath.mkColVector(vectorValues))
+    val expectedResult = vectorValues
     val actualResult = EjmlMath.toArray(vector)
 
     expectedResult.zipWithIndex.foreach { case (expectedValue, index) =>
@@ -204,21 +204,21 @@ class EjmlMathTest extends Test {
   }
 
   it should "get" in {
-    val values = Array(1f, 2f, 3f)
-    val vector = EjmlMath.t(EjmlMath.mkVector(values))
+    val vectorValues = Array(1f, 2f, 3f)
+    val vector = EjmlMath.t(EjmlMath.mkColVector(vectorValues))
     val expectedResult = 2f
     val actualResult = EjmlMath.get(vector, 1)
 
     actualResult should be (expectedResult)
   }
 
   it should "mkRowMatrix" in {
-    val values = Array(
+    val matrixValues = Array(
       Array(1f, 2f, 3f),
       Array(2f, 4f, 6f)
     )
-    val expectedResult = values
-    val actualResult = EjmlMath.mkRowMatrix(values)
+    val expectedResult = matrixValues
+    val actualResult = EjmlMath.mkRowMatrix(matrixValues)
 
     expectedResult.zipWithIndex.foreach { case (expectedValues, rowIndex) =>
       expectedValues.zipWithIndex.foreach { case (expectedValue, colIndex) =>
@@ -227,10 +227,29 @@ class EjmlMathTest extends Test {
     }
   }
 
+  it should "mkColMatrix" in {
+    val matrixValues = Array(
+      Array(1f, 2f, 3f),
+      Array(2f, 4f, 6f)
+    )
+    val expectedResult = Array(
+      Array(1f, 2f),
+      Array(2f, 4f),
+      Array(3f, 6f)
+    )
+    val actualResult = EjmlMath.mkColMatrix(matrixValues)
+
+    expectedResult.zipWithIndex.foreach { case (expectedValues, rowIndex) =>
+      expectedValues.zipWithIndex.foreach { case (expectedValue, colIndex) =>
+        actualResult.get(rowIndex, colIndex) should be(expectedValue)
+      }
+    }
+  }
+
   it should "mkVector" in {
-    val values = Array(1f, 2f, 3f)
-    val expectedResult = values
-    val actualResult = EjmlMath.mkVector(expectedResult)
+    val vectorValues = Array(1f, 2f, 3f)
+    val expectedResult = vectorValues
+    val actualResult = EjmlMath.mkColVector(expectedResult)
 
     expectedResult.zipWithIndex.foreach { case (expectedValue, index) =>
       actualResult.get(index) should be (expectedValue)