Improvements to GenericNeuralStack class

Author: mandar2812

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

@@ -2,19 +2,22 @@ package io.github.mandar2812.dynaml.models.neuralnets
 
 import io.github.mandar2812.dynaml.graph.NeuralGraph
 
+import scala.collection.GenTraversableLike
+
 /**
   * @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] {
+class GenericNeuralStack[
+P, I, Layer <: NeuralLayer[P, I, I],
+T[Layer] <: Traversable[Layer] with GenTraversableLike[Layer, T[Layer]]
+](elements: T[Layer]) extends NeuralGraph[T[Layer], I, I] {
 
   self =>
 
-  override protected val g: T = elements
+  override protected val g: T[Layer] = elements
 
   /**
     * Do a forward pass through the network outputting only the output layer activations.
@@ -27,12 +30,13 @@ P, I, T <: Traversable[NeuralLayer[P, I, I]]
     * 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))
+  def forwardPropagate(x: I): T[I] = g.scanLeft(x)((h, layer) => layer.forward(h)).asInstanceOf[T[I]]
 
   /**
     * Batch version of [[forwardPropagate()]]
     * */
-  def forwardPropagateBatch[G <: Traversable[I]](d: G): Traversable[G] = g.scanLeft(d)((h, layer) => layer.forward(h))
+  def forwardPropagateBatch[G <: Traversable[I]](d: G): T[G] =
+    g.scanLeft(d)((h, layer) => layer.forward(h)).asInstanceOf[T[G]]
 
   /**
     * Batch version of [[forwardPass()]]
@@ -42,17 +46,27 @@ P, I, T <: Traversable[NeuralLayer[P, I, I]]
   /**
     * Slice the stack according to a range.
     * */
-  def apply(r: Range): GenericNeuralStack[P, I, T]
+  def apply(r: Range): GenericNeuralStack[P, I, Layer, T] =
+    new GenericNeuralStack(self.g.slice(r.min,r.max+1).asInstanceOf[T[Layer]])
 
   /**
     * 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]
+  def ++[
+  L <: NeuralLayer[P, I, I],
+  G[L] <: Traversable[L] with GenTraversableLike[L, G[L]]](
+    otherStack: GenericNeuralStack[P, I, L, G])
+  : GenericNeuralStack[P, I, NeuralLayer[P, I, I], T] = new GenericNeuralStack[P, I, NeuralLayer[P, I, I], T](
+    (self.g.map((l: Layer) => l.asInstanceOf[NeuralLayer[P, I, I]]) ++
+      otherStack._layers.map((l: L) => l.asInstanceOf[NeuralLayer[P, I, I]]))
+      .asInstanceOf[T[NeuralLayer[P, I, I]]])
 
   /**
     * Append a single computation layer to the stack.
     * */
-  def :+(computationLayer: NeuralLayer[P, I, I]): GenericNeuralStack[P, I, T]
+  def :+(computationLayer: NeuralLayer[P, I, I])
+  : GenericNeuralStack[P, I, NeuralLayer[P, I, I], T] = self ++
+    new GenericNeuralStack[P, I, NeuralLayer[P, I, I], Seq](Seq(computationLayer))
 
 }

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

@@ -1,32 +1,39 @@
 package io.github.mandar2812.dynaml.models.neuralnets
 
+import scala.collection.GenTraversableLike
+
 
 /**
   * @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) {
+  GenericNeuralStack[P, I, NeuralLayer[P, I, I], Stream](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))
+  override def apply(r: Range): LazyNeuralStack[P, I] = 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)
+  override def ++[
+  L <: NeuralLayer[P, I, I],
+  G[L] <: Traversable[L] with GenTraversableLike[L, G[L]]](
+    otherStack: GenericNeuralStack[P, I, L, G]) =
+    new LazyNeuralStack[P, I](self.g ++ otherStack._layers.asInstanceOf[Stream[NeuralLayer[P, I, I]]])
 
   /**
     * Append a single computation layer to the stack.
     **/
-  override def :+(computationLayer: NeuralLayer[P, I, I]) = new LazyNeuralStack[P, I](self.g :+ computationLayer)
+  override def :+(computationLayer: NeuralLayer[P, I, I]): LazyNeuralStack[P, I] =
+    new LazyNeuralStack[P, I](self.g :+ computationLayer)
 }
 
 object LazyNeuralStack {

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

@@ -1,14 +1,15 @@
 package io.github.mandar2812.dynaml.models.neuralnets
 
+import scala.collection.GenTraversableLike
 import breeze.linalg.{DenseMatrix, DenseVector}
-import io.github.mandar2812.dynaml.graph.NeuralGraph
 import io.github.mandar2812.dynaml.pipes.DataPipe
 
+
 /**
   * A network, represented as a stack of [[NeuralLayer]] objects.
   * */
 class NeuralStack[P, I](elements: Seq[NeuralLayer[P, I, I]])
-  extends GenericNeuralStack[P, I, Seq[NeuralLayer[P, I, I]]](elements) {
+  extends GenericNeuralStack[P, I, NeuralLayer[P, I, I], Seq](elements) {
 
   self =>
 
@@ -42,14 +43,18 @@ class NeuralStack[P, I](elements: Seq[NeuralLayer[P, I, I]])
   /**
     * Slice the stack according to a range.
     * */
-  def apply(r: Range): NeuralStack[P, I] = NeuralStack(g.slice(r.min, r.max + 1):_*)
+  override def apply(r: Range): NeuralStack[P, I] = NeuralStack(g.slice(r.min, r.max + 1):_*)
+
 
   /**
     * Append another computation stack to the end of the
     * current one.
-    * */
-  override def ++[T <: Traversable[NeuralLayer[P, I, I]]](otherStack: GenericNeuralStack[P, I, T]) =
-    new NeuralStack(self.g ++ otherStack._layers)
+    **/
+  override def ++[
+  L <: NeuralLayer[P, I, I],
+  G[L] <: Traversable[L] with GenTraversableLike[L, G[L]]](
+    otherStack: GenericNeuralStack[P, I, L, G]) =
+    new NeuralStack(self.g ++ otherStack._layers.asInstanceOf[Seq[NeuralLayer[P, I, I]]])
 
   /**
     * Append a single computation layer to the stack.