Reformat project.

Author: MrVPlusOne

.scalafmt.conf

@@ -1,6 +1,6 @@
 version = "2.0.0-RC8"
 align = some
-maxColumn = 100
+maxColumn = 92
 assumeStandardLibraryStripMargin = true
 continuationIndent.defnSite = 4
 continuationIndent.callSite = 2

src/main/scala/botkop/numsca/package.scala

@@ -167,7 +167,6 @@ package object numsca {
   def multiply(a: Tensor, b: Tensor): Tensor = a * b
   def dot(a: Tensor, b: Tensor): Tensor = a dot b
 
-
   def clip(t: Tensor, min: Double, max: Double): Tensor = t.clip(min, max)
 
 //  def concatNd4j(ts: Seq[Tensor], axis: Int): Tensor = {

src/main/scala/funcdiff/API.scala

@@ -10,11 +10,13 @@ import TensorExtension.epsilon
 trait APITrait {
 
   sealed trait GraphMode
+
   /** [[CompNode]] created under this mode consumes less memory but does not support back
-   *  propagation. Use this mode during testing. */
+    *  propagation. Use this mode during testing. */
   case object ModeEval extends GraphMode
+
   /** [[CompNode]] created under this mode needs to keep the entire computation graph
-   * in the memory to support gradient back propagation. Use this mode during training. */
+    * in the memory to support gradient back propagation. Use this mode during training. */
   case object ModeTraining extends GraphMode
 
   var debugOpTime = true
@@ -32,7 +34,7 @@ trait APITrait {
 
   def funcNode(func: DiffFunc)(implicit mode: GraphMode): CompNode =
     mode match {
-      case ModeEval => new CompNode(ConstFunc(func.value))
+      case ModeEval     => new CompNode(ConstFunc(func.value))
       case ModeTraining => new CompNode(func)
     }
 
@@ -48,7 +50,8 @@ trait APITrait {
 
   def mean(x1: CompNode)(implicit mode: GraphMode): CompNode = funcNode(Mean(x1))
 
-  def mean(x1: CompNode, axis: Int)(implicit mode: GraphMode): CompNode = funcNode(MeanByAxis(x1, axis))
+  def mean(x1: CompNode, axis: Int)(implicit mode: GraphMode): CompNode =
+    funcNode(MeanByAxis(x1, axis))
 
   def square(x1: CompNode)(implicit mode: GraphMode): CompNode = x1 * x1
 
@@ -62,7 +65,9 @@ trait APITrait {
 
   def sum(x1: CompNode)(implicit mode: GraphMode): CompNode = funcNode(Sum(x1))
 
-  def sum(x1: CompNode, axis: Int, keepDim: Boolean = true)(implicit mode: GraphMode): CompNode =
+  def sum(x1: CompNode, axis: Int, keepDim: Boolean = true)(
+      implicit mode: GraphMode
+  ): CompNode =
     funcNode(SumByAxis(x1, axis, keepDim))
 
   def softmax(x1: CompNode)(implicit mode: GraphMode): CompNode = funcNode(Softmax(x1))
@@ -71,7 +76,8 @@ trait APITrait {
 
   def abs(x1: CompNode)(implicit mode: GraphMode): CompNode = funcNode(Abs(x1))
 
-  def max(x1: CompNode, x2: CompNode)(implicit mode: GraphMode): CompNode = funcNode(MaxBinary(x1, x2))
+  def max(x1: CompNode, x2: CompNode)(implicit mode: GraphMode): CompNode =
+    funcNode(MaxBinary(x1, x2))
 
   def plusN(xs: IS[CompNode])(implicit mode: GraphMode): CompNode = funcNode(PlusN(xs))
 
@@ -89,22 +95,32 @@ trait APITrait {
 
   def stackRows(xs: IS[CompNode])(implicit mode: GraphMode) = funcNode(StackRows(xs))
 
-  def concatTupledRows(rows: IS[(CompNode, CompNode)])(implicit mode: GraphMode): CompNode = {
+  def concatTupledRows(
+      rows: IS[(CompNode, CompNode)]
+  )(implicit mode: GraphMode): CompNode = {
     val (l, r) = rows.unzip
     stackRows(l).concat(stackRows(r), axis = 1)
   }
 
-  def crossEntropy(prediction: CompNode, targets: Tensor)(implicit mode: GraphMode): CompNode =
+  def crossEntropy(prediction: CompNode, targets: Tensor)(
+      implicit mode: GraphMode
+  ): CompNode =
     -sum(log(prediction + epsilon) * targets, axis = 1)
 
-  def crossEntropyOnSoftmax(logits: CompNode, targets: Tensor)(implicit mode: GraphMode): CompNode =
+  def crossEntropyOnSoftmax(logits: CompNode, targets: Tensor)(
+      implicit mode: GraphMode
+  ): CompNode =
     funcNode(CrossEntropyOnSoftmax(logits, targets))
 
-  def crossEntropyOnSigmoid(logits: CompNode, targets: Tensor)(implicit mode: GraphMode): CompNode = {
+  def crossEntropyOnSigmoid(logits: CompNode, targets: Tensor)(
+      implicit mode: GraphMode
+  ): CompNode = {
     funcNode(CrossEntropyOnSigmoid(logits, targets))
   }
 
-  def crossEntropyOnSoftmaxIneff(logits: CompNode, targets: Tensor)(implicit mode: GraphMode): CompNode =
+  def crossEntropyOnSoftmaxIneff(logits: CompNode, targets: Tensor)(
+      implicit mode: GraphMode
+  ): CompNode =
     -sum(log(softmax(logits) + epsilon) * targets, axis = 1)
 
   def normSquared(x1: CompNode)(implicit mode: GraphMode): CompNode =
@@ -178,7 +194,7 @@ trait APITrait {
 
   implicit class ExtendedFunctions(x1: CompNode) {
 
-    def unary_-(implicit mode: GraphMode) : CompNode = funcNode(Negate(x1))
+    def unary_-(implicit mode: GraphMode): CompNode = funcNode(Negate(x1))
 
     def t(implicit mode: GraphMode): CompNode = funcNode(Transpose(x1))
 
@@ -195,7 +211,8 @@ trait APITrait {
     def concat(x2: CompNode, axis: Int)(implicit mode: GraphMode): CompNode =
       funcNode(Concat(x1, x2, axis))
 
-    def slice(ranges: NumscaRange*)(implicit mode: GraphMode): CompNode = funcNode(Slice(x1, ranges))
+    def slice(ranges: NumscaRange*)(implicit mode: GraphMode): CompNode =
+      funcNode(Slice(x1, ranges))
 
     def dot(x2: CompNode)(implicit mode: GraphMode): CompNode = funcNode(Dot(x1, x2))
 

src/main/scala/funcdiff/CompNode.scala

@@ -17,7 +17,8 @@ class CompNode(val func: DiffFunc) extends Serializable {
 
   def shape: Shape = value.shape
 
-  def reshape(newShape: Shape)(implicit mode: GraphMode): CompNode = funcNode(Reshape(newShape, this))
+  def reshape(newShape: Shape)(implicit mode: GraphMode): CompNode =
+    funcNode(Reshape(newShape, this))
 
   def backprop: Map[CompNode, Gradient] = CompNode.backprop(this)
 
@@ -49,8 +50,7 @@ class CompNode(val func: DiffFunc) extends Serializable {
 }
 
 @SerialVersionUID(2L)
-class ParamNode(v: Tensor, val path: SymbolPath)
-    extends CompNode(ConstFunc(v)) {
+class ParamNode(v: Tensor, val path: SymbolPath) extends CompNode(ConstFunc(v)) {
 
   override def toString: String = {
     s"param{$path, shape=${value.shape}"

src/main/scala/funcdiff/DiffFunc.scala

@@ -147,8 +147,7 @@ private[funcdiff] object DiffFunc {
     def name: String = "sum"
   }
 
-  case class SumByAxis(x1: CompNode, axis: Int, keepDim: Boolean = true)
-      extends UnaryFunc {
+  case class SumByAxis(x1: CompNode, axis: Int, keepDim: Boolean = true) extends UnaryFunc {
     val value: Tensor = ns.sumAxis(x1.value, axis, keepDim)
 
     def backprop1(grad: Gradient): Gradient = {
@@ -174,8 +173,7 @@ private[funcdiff] object DiffFunc {
   }
 
   case class LeakyRelu(x1: CompNode, slope: Double) extends UnaryFunc {
-    val value
-        : Tensor = ns.maximum(x1.value, 0.0) + ns.minimum(x1.value, 0.0) * slope
+    val value: Tensor = ns.maximum(x1.value, 0.0) + ns.minimum(x1.value, 0.0) * slope
 
     def backprop1(grad: Gradient): Gradient = {
       grad * ((x1.value > 0).boolToFloating + (x1.value < 0).boolToFloating * slope)
@@ -391,10 +389,9 @@ private[funcdiff] object DiffFunc {
   }
 
   /**
-   * @param fromRows Whether all arguments are row vectors and have the same shape.
-   */
-  case class ConcatN(args: IS[CompNode], axis: Int, fromRows: Boolean)
-      extends DiffFunc {
+    * @param fromRows Whether all arguments are row vectors and have the same shape.
+    */
+  case class ConcatN(args: IS[CompNode], axis: Int, fromRows: Boolean) extends DiffFunc {
 
     val value: Tensor =
       if (fromRows) ns.fromRows(args.map(_.value), axis)
@@ -445,8 +442,7 @@ private[funcdiff] object DiffFunc {
   }
 
   // ================ Loss functions ======================
-  case class CrossEntropyOnSoftmax(logits: CompNode, targets: Tensor)
-      extends UnaryFunc {
+  case class CrossEntropyOnSoftmax(logits: CompNode, targets: Tensor) extends UnaryFunc {
     require(
       targets.shape == logits.shape,
       s"Targets shape (${targets.shape}) is different from logits (${logits.shape})."
@@ -472,8 +468,7 @@ private[funcdiff] object DiffFunc {
     }
   }
 
-  case class CrossEntropyOnSigmoid(logits: CompNode, targets: Tensor)
-      extends UnaryFunc {
+  case class CrossEntropyOnSigmoid(logits: CompNode, targets: Tensor) extends UnaryFunc {
     require(targets.shape(1) == 1)
     require(logits.shape(1) == 1)
 

src/main/scala/funcdiff/LayerFactory.scala

@@ -96,41 +96,42 @@ case class LayerFactory(
   def gru(
       name: SymbolPath,
       initializer: WeightsInitializer = LayerFactory.xavier
-  )(state: CompNode, input: CompNode)(implicit mode: GraphMode): CompNode = withPrefix(name) { prefix =>
-    val inputSize = input.shape(1)
-    val stateSize = state.shape(1)
-
-    val Wg = paramCollection
-      .getVar(prefix / 'Wg, attributes = Set(NeedRegularization)) {
-        initializer(inputSize, 2 * stateSize)
-      }
-    val Ug = paramCollection
-      .getVar(prefix / 'Ug, attributes = Set(NeedRegularization)) {
-        initializer(stateSize, 2 * stateSize)
+  )(state: CompNode, input: CompNode)(implicit mode: GraphMode): CompNode =
+    withPrefix(name) { prefix =>
+      val inputSize = input.shape(1)
+      val stateSize = state.shape(1)
+
+      val Wg = paramCollection
+        .getVar(prefix / 'Wg, attributes = Set(NeedRegularization)) {
+          initializer(inputSize, 2 * stateSize)
+        }
+      val Ug = paramCollection
+        .getVar(prefix / 'Ug, attributes = Set(NeedRegularization)) {
+          initializer(stateSize, 2 * stateSize)
+        }
+      val bg = paramCollection.getVar(prefix / 'bg) {
+        ns.zeros(1, 2 * stateSize)
       }
-    val bg = paramCollection.getVar(prefix / 'bg) {
-      ns.zeros(1, 2 * stateSize)
-    }
 
-    val gates = sigmoid(input.dot(Wg) + state.dot(Ug) + bg)
-    val updateGate = gates.slice(:>, 0 :> stateSize)
-    val restGate = gates.slice(:>, stateSize :>)
-
-    val Wh = paramCollection
-      .getVar(prefix / 'Wh, attributes = Set(NeedRegularization)) {
-        initializer(inputSize, stateSize)
+      val gates = sigmoid(input.dot(Wg) + state.dot(Ug) + bg)
+      val updateGate = gates.slice(:>, 0 :> stateSize)
+      val restGate = gates.slice(:>, stateSize :>)
+
+      val Wh = paramCollection
+        .getVar(prefix / 'Wh, attributes = Set(NeedRegularization)) {
+          initializer(inputSize, stateSize)
+        }
+      val Uh = paramCollection
+        .getVar(prefix / 'Uh, attributes = Set(NeedRegularization)) {
+          initializer(stateSize, stateSize)
+        }
+      val bh = paramCollection.getVar(prefix / 'bh) {
+        ns.zeros(1, stateSize)
       }
-    val Uh = paramCollection
-      .getVar(prefix / 'Uh, attributes = Set(NeedRegularization)) {
-        initializer(stateSize, stateSize)
-      }
-    val bh = paramCollection.getVar(prefix / 'bh) {
-      ns.zeros(1, stateSize)
-    }
 
-    val hHat = tanh(input.dot(Wh) + (state * restGate).dot(Uh) + bh)
-    updateGate * hHat + state * (-updateGate + 1)
-  }
+      val hHat = tanh(input.dot(Wh) + (state * restGate).dot(Uh) + bh)
+      updateGate * hHat + state * (-updateGate + 1)
+    }
 
   /**
     * Long short-term memory unit: [https://en.wikipedia.org/wiki/Long_short-term_memory]
@@ -195,19 +196,20 @@ case class LayerFactory(
       name: SymbolPath,
       stateShape: Shape,
       combiner: (CompNode, CompNode) => CompNode
-  )(inputs: IS[CompNode])(implicit mode: GraphMode): IS[CompNode] = withPrefix(name) { prefix =>
-    val leftInit: CompNode = getVar(prefix / 'leftInit) {
-      ns.randn(stateShape)
-    }
-    val states1 = inputs.scanLeft(leftInit)(gru(name / 'leftRNN))
-    val rightInit: CompNode = getVar(prefix / 'rightInit) {
-      ns.randn(stateShape)
-    }
-    val states2 =
-      inputs.reverse.scanLeft(rightInit)(gru(name / 'rightRNN)).reverse
-    states1.zip(states2).map {
-      case (l, r) => combiner(l, r)
-    }
+  )(inputs: IS[CompNode])(implicit mode: GraphMode): IS[CompNode] = withPrefix(name) {
+    prefix =>
+      val leftInit: CompNode = getVar(prefix / 'leftInit) {
+        ns.randn(stateShape)
+      }
+      val states1 = inputs.scanLeft(leftInit)(gru(name / 'leftRNN))
+      val rightInit: CompNode = getVar(prefix / 'rightInit) {
+        ns.randn(stateShape)
+      }
+      val states2 =
+        inputs.reverse.scanLeft(rightInit)(gru(name / 'rightRNN)).reverse
+      states1.zip(states2).map {
+        case (l, r) => combiner(l, r)
+      }
   }
 
   /** performs weighted-sum over ys using dot-product attention */

src/main/scala/funcdiff/Optimizer.scala

@@ -57,7 +57,7 @@ trait Optimizer extends Serializable {
         (path, g) <- transformed
         p <- paramMap.get(path).toIterable
         delta = parameterChangeAmount(p, g) * scaleLearningRate
-      } yield p.synchronized{
+      } yield p.synchronized {
         if (newlyCreated contains p.node) {
           delta.addToTensor(p.node.value)
         } else {

src/main/scala/funcdiff/Param.scala

@@ -13,14 +13,14 @@ object ParameterAttribute {
 }
 
 /**
- * Each [[Param]] contains a mutable [[ParamNode]], representing a trainable parameter.
- *
- * Note that in the future, [[Param]] will not be serializable and should only be provided by
- * [[ParamCollection]] to ensure reference consistency. (currently keep it serializable
- * to be able to load previously trained model)
- *
- * todo: make this not serializable
- */
+  * Each [[Param]] contains a mutable [[ParamNode]], representing a trainable parameter.
+  *
+  * Note that in the future, [[Param]] will not be serializable and should only be provided by
+  * [[ParamCollection]] to ensure reference consistency. (currently keep it serializable
+  * to be able to load previously trained model)
+  *
+  * todo: make this not serializable
+  */
 @SerialVersionUID(1L)
 class Param(
     var node: ParamNode,
@@ -41,7 +41,7 @@ case class SymbolPath(repr: Symbol) {
     })
 
   @inline
-  def /(seg: String): SymbolPath = this/Symbol(seg)
+  def /(seg: String): SymbolPath = this / Symbol(seg)
 
   def ++(other: SymbolPath): SymbolPath = this / other.repr
 

src/main/scala/funcdiff/SimpleMath.scala

@@ -2,7 +2,15 @@ package funcdiff
 
 import ammonite.ops.Path
 
-import java.io.{File, FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream, ObjectStreamClass, Serializable}
+import java.io.{
+  File,
+  FileInputStream,
+  FileOutputStream,
+  ObjectInputStream,
+  ObjectOutputStream,
+  ObjectStreamClass,
+  Serializable
+}
 import scala.util.Random
 import collection.mutable
 import Numeric.Implicits._
@@ -106,7 +114,7 @@ object SimpleMath {
   def mean[T: Numeric](xs: Iterable[T]): Double = xs.sum.toDouble / xs.size
 
   def variance[T: Numeric](xs: Iterable[T]): Double = {
-    if(xs.size > 1) {
+    if (xs.size > 1) {
       val mu = mean(xs)
       xs.map(x => square(x.toDouble() - mu)).sum / (xs.size - 1)
     } else Double.NaN
@@ -465,10 +473,11 @@ object SimpleMath {
 
     def show: String = {
       stat.toSeq
-        .sortBy(_._2).reverseMap {
-        case (name, time) =>
-          s"$name: ${prettyPrintTime(time)}"
-      }
+        .sortBy(_._2)
+        .reverseMap {
+          case (name, time) =>
+            s"$name: ${prettyPrintTime(time)}"
+        }
         .mkString("\n")
     }
   }