X-Git-Url: https://www.fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=dagnn.lua;h=7fc1018f8dd7f3f88021c914608c5af1f5a710a5;hb=116fbcd681f9e097f7acd89f61a15c6b7bd113ce;hp=0f93d95f63a87b320d9e6d261a89c9798b4d9b55;hpb=d0743d66135ed7cedcb3777cfa5dda883cbeadb3;p=dagnn.git

diff --git a/dagnn.lua b/dagnn.lua
index 0f93d95..7fc1018 100755
--- a/dagnn.lua
+++ b/dagnn.lua
@@ -1,4 +1,23 @@
 
+--[[
+
+   Copyright (c) 2016 Idiap Research Institute, http://www.idiap.ch/
+   Written by Francois Fleuret <francois.fleuret@idiap.ch>
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License version 3 as
+   published by the Free Software Foundation.
+
+   It is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+   License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this file.  If not, see <http://www.gnu.org/licenses/>.
+
+]]--
+
 require 'torch'
 require 'nn'
 
@@ -13,9 +32,11 @@ 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
 
@@ -79,14 +100,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
@@ -109,6 +126,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()
 
@@ -117,13 +150,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
@@ -142,7 +178,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
 
@@ -154,27 +191,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
    )
 
@@ -193,7 +217,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
@@ -217,23 +243,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
 
-return DAG
+----------------------------------------------------------------------