Merge pull request #215 from Atry/products

Add Products and HLists to Builtins

Author: Atry

build.sbt

@@ -18,6 +18,8 @@ lazy val `plugins-Operators` = project
 
 lazy val `plugins-HLists` = project.dependsOn(DeepLearning)
 
+lazy val `plugins-Products` = project.dependsOn(`plugins-HLists`)
+
 lazy val `plugins-FloatTraining` = project.dependsOn(`plugins-Training`)
 
 lazy val `plugins-FloatLiterals` = project.dependsOn(`DeepLearning`)
@@ -40,7 +42,8 @@ lazy val `plugins-CumulativeFloatLayers` =
     `plugins-FloatTraining` % Test,
     `plugins-FloatLiterals` % Test,
     `plugins-FloatWeights` % Test,
-    `plugins-ImplicitsSingleton` % Test
+    `plugins-ImplicitsSingleton` % Test,
+    `plugins-Products` % Test
   )
 
 lazy val `plugins-Training` = project.dependsOn(DeepLearning)
@@ -116,6 +119,7 @@ lazy val `plugins-CumulativeDoubleLayers` =
 
 lazy val `plugins-Builtins` =
   project.dependsOn(
+    `plugins-Products`,
     `plugins-HLists`,
     `plugins-ImplicitsSingleton`,
     `plugins-Layers`,

plugins-Builtins/src/main/scala-2.11/com/thoughtworks/deeplearning/plugins/Builtins.scala

@@ -103,7 +103,9 @@ trait Builtins
     with INDArrayLiterals
     with INDArrayWeights
     with INDArrayLayers
-    with CumulativeINDArrayLayers {
+    with CumulativeINDArrayLayers
+    with HLists
+    with Products {
 
   trait ImplicitsApi
       extends super[Layers].ImplicitsApi
@@ -118,6 +120,8 @@ trait Builtins
       with super[INDArrayTraining].ImplicitsApi
       with super[INDArrayLiterals].ImplicitsApi
       with super[INDArrayLayers].ImplicitsApi
+      with super[HLists].ImplicitsApi
+      with super[Products].ImplicitsApi
 
   type Implicits <: ImplicitsApi
 

plugins-Builtins/src/main/scala-2.12/com/thoughtworks/deeplearning/plugins/Builtins.scala

@@ -20,7 +20,9 @@ trait Builtins
     with DoubleLiterals
     with DoubleWeights
     with DoubleLayers
-    with CumulativeDoubleLayers {
+    with CumulativeDoubleLayers
+    with HLists
+    with Products {
 
   trait ImplicitsApi
       extends super[Layers].ImplicitsApi
@@ -32,6 +34,8 @@ trait Builtins
       with super[DoubleTraining].ImplicitsApi
       with super[DoubleLiterals].ImplicitsApi
       with super[DoubleLayers].ImplicitsApi
+      with super[HLists].ImplicitsApi
+      with super[Products].ImplicitsApi
 
   type Implicits <: ImplicitsApi
 

plugins-CumulativeFloatLayers/src/test/scala/com/thoughtworks/deeplearning/plugins/CumulativeFloatLayersSpec.scala

@@ -379,31 +379,58 @@ final class CumulativeFloatLayersSpec
 
   }
 
-  "EagerExecution" in {
+  "eager execution" - {
+    "single expression" in {
+      val hyperparameters =
+        Factory[FloatTraining with Operators with FloatLiterals with CumulativeFloatLayers with ImplicitsSingleton with FixedLearningRate]
+          .newInstance(fixedLearningRate = 1.0f)
 
-    val hyperparameters =
-      Factory[FloatTraining with Operators with FloatLiterals with CumulativeFloatLayers with ImplicitsSingleton with FixedLearningRate]
-        .newInstance(fixedLearningRate = 1.0f)
+      import hyperparameters.implicits._
 
-    import hyperparameters.implicits._
+      val weight = hyperparameters.FloatWeight(1.0f)
 
-    val weight = hyperparameters.FloatWeight(1.0f)
+      def myNetwork(input: Float): hyperparameters.FloatLayer = {
+        6.7f + !(input + weight) + weight + 5.5f
+      }
 
-    def myNetwork(input: Float): hyperparameters.FloatLayer = {
-      6.7f + !(input + weight) + weight + 5.5f
-    }
+      def train(inputData: Float): Future[Float] = {
+        myNetwork(inputData).train
+      }
 
-    def train(inputData: Float): Future[Float] = {
-      myNetwork(inputData).train
+      for {
+        _ <- train(1.0f)
+        _ <- train(1.0f)
+        _ <- train(1.0f)
+        _ <- train(1.0f)
+        _ <- train(1.0f)
+      } yield weight.data should be(-4)
     }
 
-    for {
-      _ <- train(1.0f)
-      _ <- train(1.0f)
-      _ <- train(1.0f)
-      _ <- train(1.0f)
-      _ <- train(1.0f)
-    } yield weight.data should be(-4)
+    "multiple expression" in {
+      val hyperparameters =
+        Factory[Products with FloatTraining with Operators with FloatLiterals with CumulativeFloatLayers with ImplicitsSingleton with FixedLearningRate]
+          .newInstance(fixedLearningRate = 1.0f)
+
+      import hyperparameters.implicits._
 
+      val weight = hyperparameters.FloatWeight(1.0f)
+
+      def myNetwork(input: Float): hyperparameters.FloatLayer = {
+        val (a, b, c) = !(input + weight, 2.0f, weight)
+        6.7f + a + b + c + weight + 5.5f
+      }
+
+      def train(inputData: Float): Future[Float] = {
+        myNetwork(inputData).train
+      }
+
+      for {
+        _ <- train(1.0f)
+        _ <- train(1.0f)
+        _ <- train(1.0f)
+        _ <- train(1.0f)
+        _ <- train(1.0f)
+      } yield weight.data should be(-4)
+    }
   }
 }

plugins-Products/src/main/scala/com/thoughtworks/deeplearning/plugins/Products.scala

@@ -0,0 +1,40 @@
+package com.thoughtworks.deeplearning
+package plugins
+import com.thoughtworks.continuation.UnitContinuation
+import com.thoughtworks.deeplearning.DeepLearning.Tape
+import com.thoughtworks.raii.asynchronous._
+import shapeless.{::, Generic, HList}
+import scalaz.syntax.all._
+import shapeless.ops.hlist.Tupler
+
+/**
+  * @author 杨博 (Yang Bo)
+  */
+trait Products extends HLists {
+
+  trait ImplicitsApi extends super.ImplicitsApi {
+
+    implicit def productDeepLearning[Operand, L, DataHList <: HList, DeltaHList <: HList, DataTuple, DeltaTuple](
+        implicit generic: Generic.Aux[Operand, L],
+        deepLearning: DeepLearning.Aux[L, DataHList, DeltaHList],
+        dataTupler: Tupler.Aux[DataHList, DataTuple],
+        deltaTupler: Tupler.Aux[DeltaHList, DeltaTuple],
+        genericDelta: Generic.Aux[DeltaTuple, DeltaHList]
+    ): DeepLearning.Aux[Operand, DataTuple, DeltaTuple] =
+      new DeepLearning[Operand] {
+        type Data = DataTuple
+        type Delta = DeltaTuple
+        def forward(differentiable: Operand): Do[Tape[Data, Delta]] = {
+          deepLearning.forward(generic.to(differentiable)).map {
+            case Tape(hlistData, hlistForward) =>
+              def forward(doDeltaTuple: Do[DeltaTuple]): UnitContinuation[Unit] = {
+                hlistForward(doDeltaTuple.map(genericDelta.to))
+              }
+              Tape(dataTupler(hlistData), forward)
+          }
+        }
+      }
+  }
+
+  type Implicits <: ImplicitsApi
+}