Appending Neural Stack API

 - Added base class GenericNeuralStack
 - Added LazyNeuralStack for layers which are lazily spawned

Author: mandar2812

dynaml-core/src/main/scala-2.11/io/github/mandar2812/dynaml/models/neuralnets/GenericNeuralStack.scala

@@ -0,0 +1,58 @@
+package io.github.mandar2812.dynaml.models.neuralnets
+
+import io.github.mandar2812.dynaml.graph.NeuralGraph
+
+/**
+  * @author mandar2812 date 17/04/2017.
+  *
+  * Base class for Neural Computation Stack
+  * implementations.
+  * */
+abstract class GenericNeuralStack[
+P, I, T <: Traversable[NeuralLayer[P, I, I]]
+](elements: T) extends NeuralGraph[T, I, I] {
+
+  self =>
+
+  override protected val g: T = elements
+
+  /**
+    * Do a forward pass through the network outputting only the output layer activations.
+    * */
+  override val forwardPass: (I) => I = (x: I) => g.foldLeft(x)((h, layer) => layer.forward(h))
+
+  def _layers = g
+
+  /**
+    * Do a forward pass through the network outputting all the intermediate.
+    * layer activations.
+    * */
+  def forwardPropagate(x: I): Traversable[I] = g.scanLeft(x)((h, layer) => layer.forward(h))
+
+  /**
+    * Batch version of [[forwardPropagate()]]
+    * */
+  def forwardPropagateBatch[G <: Traversable[I]](d: G): Traversable[G] = g.scanLeft(d)((h, layer) => layer.forward(h))
+
+  /**
+    * Batch version of [[forwardPass()]]
+    * */
+  def forwardPassBatch[G <: Traversable[I]](d: G): G = g.foldLeft(d)((h, layer) => layer.forward(h))
+
+  /**
+    * Slice the stack according to a range.
+    * */
+  def apply(r: Range): GenericNeuralStack[P, I, T]
+
+  /**
+    * Append another computation stack to the end of the
+    * current one.
+    * */
+  def ++[G <: Traversable[NeuralLayer[P, I, I]]](otherStack: GenericNeuralStack[P, I, G]): GenericNeuralStack[P, I, T]
+
+  /**
+    * Append a single computation layer to the stack.
+    * */
+  def :+(computationLayer: NeuralLayer[P, I, I]): GenericNeuralStack[P, I, T]
+
+}

dynaml-core/src/main/scala-2.11/io/github/mandar2812/dynaml/models/neuralnets/LazyNeuralStack.scala

@@ -0,0 +1,39 @@
+package io.github.mandar2812.dynaml.models.neuralnets
+
+
+/**
+  * @author mandar2812 date: 17/04/2017.
+  *
+  * A computation stack whose layers are lazily computed
+  * */
+class LazyNeuralStack[P, I](elements: Stream[NeuralLayer[P, I, I]]) extends
+  GenericNeuralStack[P, I, Stream[NeuralLayer[P, I, I]]](elements) {
+
+  self =>
+
+  /**
+    * Slice the stack according to a range.
+    **/
+  override def apply(r: Range) = new LazyNeuralStack[P, I](g.slice(r.min, r.max + 1))
+
+  /**
+    * Append another computation stack to the end of the
+    * current one.
+    **/
+  override def ++[G <: Traversable[NeuralLayer[P, I, I]]](
+    otherStack: GenericNeuralStack[P, I, G]) = new LazyNeuralStack[P, I](self.g ++ otherStack._layers)
+
+  /**
+    * Append a single computation layer to the stack.
+    **/
+  override def :+(computationLayer: NeuralLayer[P, I, I]) = new LazyNeuralStack[P, I](self.g :+ computationLayer)
+}
+
+object LazyNeuralStack {
+
+  def apply[P, I](
+    layerFunc: (Int) => NeuralLayer[P, I, I],
+    num_layers: Int) = new LazyNeuralStack[P, I](
+    (0 until num_layers).toStream.map(i => layerFunc(i))
+  )
+}

dynaml-core/src/main/scala-2.11/io/github/mandar2812/dynaml/models/neuralnets/NeuralStack.scala

@@ -7,35 +7,37 @@ import io.github.mandar2812.dynaml.pipes.DataPipe
 /**
   * A network, represented as a stack of [[NeuralLayer]] objects.
   * */
-class NeuralStack[P, I](elements: NeuralLayer[P, I, I]*)
-  extends NeuralGraph[Seq[NeuralLayer[P, I, I]], I, I] {
+class NeuralStack[P, I](elements: Seq[NeuralLayer[P, I, I]])
+  extends GenericNeuralStack[P, I, Seq[NeuralLayer[P, I, I]]](elements) {
+
+  self =>
 
   override protected val g: Seq[NeuralLayer[P, I, I]] = elements
 
   val layerParameters: Seq[P] = g.map(_.parameters)
 
-  def _layers = g
+  override def _layers = g
 
   /**
     * Do a forward pass through the network outputting all the intermediate.
     * layer activations.
     * */
-  def forwardPropagate(x: I): Seq[I] = g.scanLeft(x)((h, layer) => layer.forward(h))
+  override def forwardPropagate(x: I): Seq[I] = g.scanLeft(x)((h, layer) => layer.forward(h))
 
   /**
     * Do a forward pass through the network outputting only the output layer activations.
     * */
-  val forwardPass: (I) => I = (x: I) => g.foldLeft(x)((h, layer) => layer.forward(h))
+  override val forwardPass: (I) => I = (x: I) => g.foldLeft(x)((h, layer) => layer.forward(h))
 
   /**
     * Batch version of [[forwardPropagate()]]
     * */
-  def forwardPropagateBatch[T <: Traversable[I]](d: T): Seq[T] = g.scanLeft(d)((h, layer) => layer.forward(h))
+  override def forwardPropagateBatch[T <: Traversable[I]](d: T): Seq[T] = g.scanLeft(d)((h, layer) => layer.forward(h))
 
   /**
     * Batch version of [[forwardPass()]]
     * */
-  def forwardPassBatch[T <: Traversable[I]](d: T): T = g.foldLeft(d)((h, layer) => layer.forward(h))
+  override def forwardPassBatch[T <: Traversable[I]](d: T): T = g.foldLeft(d)((h, layer) => layer.forward(h))
 
   /**
     * Slice the stack according to a range.
@@ -46,18 +48,20 @@ class NeuralStack[P, I](elements: NeuralLayer[P, I, I]*)
     * Append another computation stack to the end of the
     * current one.
     * */
-  def ++(otherStack: NeuralStack[P, I]): NeuralStack[P, I] = NeuralStack(this.g ++ otherStack.g :_*)
+  override def ++[T <: Traversable[NeuralLayer[P, I, I]]](otherStack: GenericNeuralStack[P, I, T]) =
+    new NeuralStack(self.g ++ otherStack._layers)
 
   /**
     * Append a single computation layer to the stack.
     * */
-  def :+(computationLayer: NeuralLayer[P, I, I]): NeuralStack[P, I] = NeuralStack(this.g :+ computationLayer :_*)
+  override def :+(computationLayer: NeuralLayer[P, I, I]): NeuralStack[P, I] =
+    NeuralStack(self.g :+ computationLayer :_*)
 
 }
 
 object NeuralStack {
 
-  def apply[P, I](elements: NeuralLayer[P, I, I]*): NeuralStack[P, I] = new NeuralStack(elements:_*)
+  def apply[P, I](elements: NeuralLayer[P, I, I]*): NeuralStack[P, I] = new NeuralStack(elements)
 }
 
 /**