X-Git-Url: https://www.fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=dagnn.lua;h=9202932da2950905fc49734c8762226e0e4d6f28;hb=be353fdfc2a57172064a024f8cec6015c9d908e5;hp=158ef785d446fb22f6226248c6a07c83cf47b6c3;hpb=e6516772e13dd5424f0a1b7e2063a7417614844c;p=dagnn.git

diff --git a/dagnn.lua b/dagnn.lua
index 158ef78..9202932 100755
--- a/dagnn.lua
+++ b/dagnn.lua
@@ -32,18 +32,27 @@ end
 function DAG:createNode(nnm)
    if not self.node[nnm] then
       self:add(nnm) -- Add it to the object as a Container
-      self.node[nnm] = {}
-      self.node[nnm].succ = {}
-      self.node[nnm].pred = {}
+      local node = {}
+      node.succ = {}
+      node.pred = {}
+      node.index = #self.modules
+      self.node[nnm] = node
    end
 end
 
-function DAG:addEdge(nnma, nnmb)
+-- The main use should be to add an edge between two modules, but it
+-- can also add a full sequence of modules
+function DAG:addEdge(...)
    self.sorted = nil
-   self:createNode(nnma)
-   self:createNode(nnmb)
-   table.insert(self.node[nnmb].pred, nnma)
-   table.insert(self.node[nnma].succ, nnmb)
+   local prev
+   for _, nnm in pairs({...}) do
+      self:createNode(nnm)
+      if prev then
+         table.insert(self.node[nnm].pred, prev)
+         table.insert(self.node[prev].succ, nnm)
+      end
+      prev = nnm
+   end
 end
 
 -- Apply f on t recursively; use the corresponding element from args
@@ -98,14 +107,10 @@ function DAG:putInOrder()
       return
    end
 
-   -- First, we sort the nodes according to the DAG order
-
    local distance = {}
-
    self:nestedApply(function(m) distance[m] = 1 end, self.inputModules)
 
    local nc
-
    repeat
       nc = 0
       for nnma, node in pairs(self.node) do
@@ -128,6 +133,22 @@ function DAG:putInOrder()
    for i, a in ipairs(self.sorted) do self.sorted[i] = a.nnm end
 end
 
+function DAG:computeGradOutput(gradInputSucc)
+   local gi
+   if #gradInputSucc == 1 then
+      gi = gradInputSucc[1] -- we avoid a clone()
+   elseif #gradInputSucc > 1 then
+      for k = 1, #gradInputSucc do
+         if gi then
+            gi:add(gradInputSucc[k])
+         else
+            gi = gradInputSucc[k]:clone()
+         end
+      end
+   end
+   return gi
+end
+
 function DAG:print()
    self:putInOrder()
 
@@ -136,13 +157,16 @@ function DAG:print()
    end
 end
 
+----------------------------------------------------------------------
+
 function DAG:updateOutput(input)
    self:putInOrder()
 
    self:nestedApply(
       function(nnm, i)
          self.node[nnm].input = i
-         nnm:updateOutput(i)
+         -- nnm:updateOutput(i)
+         self:rethrowErrors(nnm, self.node[nnm].index, 'updateOutput', i)
       end,
       self.inputModules,
       input
@@ -161,7 +185,8 @@ function DAG:updateOutput(input)
             end
          end
          node.input = i
-         nnm:updateOutput(i)
+         -- nnm:updateOutput(i)
+         self:rethrowErrors(nnm, self.node[nnm].index, 'updateOutput', i)
       end
    end
 
@@ -173,27 +198,14 @@ function DAG:updateOutput(input)
    return self.output
 end
 
-function DAG:computeGradInput(gradInputSucc)
-   local gi
-   if #gradInputSucc == 1 then
-      gi = gradInputSucc[1] -- we avoid a clone()
-   elseif #gradInputSucc > 1 then
-      for k = 1, #gradInputSucc do
-         if gi then
-            gi:add(gradInputSucc[k])
-         else
-            gi = gradInputSucc[k]:clone()
-         end
-      end
-   end
-   return gi
-end
-
 function DAG:updateGradInput(input, gradOutput)
-   self:putInOrder()
+   assert(self.sorted, 'there has been a DAG structure change before a DAG:updateGradInput')
 
    self:nestedApply(
-      function(nnm, go) nnm:updateGradInput(self.node[nnm].input, go) end,
+      function(nnm, go)
+         -- nnm:updateGradInput(self.node[nnm].input, go)
+         self:rethrowErrors(nnm, self.node[nnm].index, 'updateGradInput', self.node[nnm].input, go)
+      end,
       self.outputModules, gradOutput
    )
 
@@ -212,7 +224,9 @@ function DAG:updateGradInput(input, gradOutput)
       local pred, gradInputSucc = node.pred, node.gradInputSucc
 
       if #gradInputSucc > 0 then
-         nnm:updateGradInput(node.input, self:computeGradInput(gradInputSucc))
+         node.gradOutput = self:computeGradOutput(gradInputSucc)
+         -- nnm:updateGradInput(node.input, node.gradOutput)
+         self:rethrowErrors(nnm, self.node[nnm].index, 'updateGradInput', node.input, node.gradOutput)
       end
 
       -- We fill the gradInputSucc of our predecessors
@@ -236,21 +250,14 @@ end
 function DAG:accGradParameters(input, gradOutput, scale)
    scale = scale or 1
 
-   self:putInOrder()
+   assert(self.sorted, 'there has been a DAG structure change before a DAG:accGradParameters')
 
-   self:nestedApply(
-      function(nnm, go) nnm:updateGradInput(self.node[nnm].input, go) end,
-      self.outputModules, gradOutput
-   )
-
-   self:nestedApply(
-      function(nnm, i) self.node[nnm].input = i end,
-      self.inputModules, input
-   )
-
-   for k = #self.sorted, 1, -1 do
-      local nnm = self.sorted[k]
+   for k = 1, #self.modules do
+      local nnm = self.modules[k]
       local node = self.node[nnm]
-      nnm:accGradParameters(node.input, self:computeGradInput(node.gradInputSucc), scale)
+      -- nnm:accGradParameters(node.input, node.gradOutput, scale)
+      self:rethrowErrors(nnm, k, 'accGradParameters', node.input, self:computeGradOutput(node.gradInputSucc), scale)
    end
 end
+
+----------------------------------------------------------------------