X-Git-Url: https://www.fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=dagnn.lua;h=0c1d15303f42ce6e8ad439b787bffe29664511c3;hb=e50d9b4373f39161df34afb1033c89910963fa47;hp=7fc1018f8dd7f3f88021c914608c5af1f5a710a5;hpb=063f198047f0202fa921aa09b772369b14ae8be2;p=dagnn.git

diff --git a/dagnn.lua b/dagnn.lua
index 7fc1018..0c1d153 100755
--- a/dagnn.lua
+++ b/dagnn.lua
@@ -29,26 +29,7 @@ function DAG:__init()
    self.node = { }
 end
 
-function DAG:createNode(nnm)
-   if not self.node[nnm] then
-      self:add(nnm) -- Add it to the object as a Container
-      local node = {}
-      node.succ = {}
-      node.pred = {}
-      node.index = #self.modules
-      self.node[nnm] = node
-   end
-end
-
-function DAG:addEdge(nnma, nnmb)
-   self.sorted = nil
-   self:createNode(nnma)
-   self:createNode(nnmb)
-   table.insert(self.node[nnmb].pred, nnma)
-   table.insert(self.node[nnma].succ, nnmb)
-end
-
--- Apply f on t recursively; use the corresponding element from args
+-- Apply f on t recursively; use the corresponding elements from args
 -- (i.e. same keys) as second parameter to f when available; return
 -- the results from f, organized in a similarly nested table.
 function DAG:nestedApply(f, t, args)
@@ -63,36 +44,15 @@ function DAG:nestedApply(f, t, args)
    end
 end
 
-function DAG:setInput(i)
-   self.sorted = nil
-   self.inputModules = i
-   self:nestedApply(
-      function(nnm)
-         if #self.node[nnm].succ == 0 then
-            error('Input modules must have outgoing  edges.')
-         end
-         if #self.node[nnm].pred > 0 then
-            error('Input modules cannog have incoming edges.')
-         end
-      end,
-      self.inputModules
-   )
-end
-
-function DAG:setOutput(o)
-   self.sorted = nil
-   self.outputModules = o
-   self:nestedApply(
-      function(nnm)
-         if #self.node[nnm].pred == 0 then
-            error('Output module must have incoming edges.')
-         end
-         if #self.node[nnm].succ > 0 then
-            error('Output module cannot have outgoing edges.')
-         end
-      end,
-      self.outputModules
-   )
+function DAG:createNode(nnm)
+   if not self.node[nnm] then
+      self:add(nnm) -- Add it to the object as a Container
+      local node = {}
+      node.succ = {}
+      node.pred = {}
+      node.index = #self.modules
+      self.node[nnm] = node
+   end
 end
 
 function DAG:putInOrder()
@@ -142,6 +102,54 @@ function DAG:computeGradOutput(gradInputSucc)
    return gi
 end
 
+----------------------------------------------------------------------
+
+-- Connect a sequence of modules
+function DAG:connect(...)
+   self.sorted = nil
+   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
+
+function DAG:setInput(i)
+   self.sorted = nil
+   self.inputModules = i
+   self:nestedApply(
+      function(nnm)
+         if #self.node[nnm].succ == 0 then
+            error('Input modules must have outgoing  edges.')
+         end
+         if #self.node[nnm].pred > 0 then
+            error('Input modules cannog have incoming edges.')
+         end
+      end,
+      self.inputModules
+   )
+end
+
+function DAG:setOutput(o)
+   self.sorted = nil
+   self.outputModules = o
+   self:nestedApply(
+      function(nnm)
+         if #self.node[nnm].pred == 0 then
+            error('Output module must have incoming edges.')
+         end
+         if #self.node[nnm].succ > 0 then
+            error('Output module cannot have outgoing edges.')
+         end
+      end,
+      self.outputModules
+   )
+end
+
 function DAG:print()
    self:putInOrder()
 
@@ -152,6 +160,46 @@ end
 
 ----------------------------------------------------------------------
 
+function DAG:saveDot(filename)
+   local file = (filename and io.open(filename, 'w')) or io.stdout
+
+   file:write('digraph {\n')
+
+   file:write('\n')
+
+   for nnmb, node in pairs(self.node) do
+      file:write(
+         '  '
+            .. node.index
+            .. ' [shape=box,label=\"' .. torch.type(nnmb) .. '\"]'
+            .. '\n'
+      )
+
+      for i, nnma in pairs(node.pred) do
+         local decoration = ''
+         if #node.pred > 1 then
+            -- decoration = ' [headlabel=\"' .. i .. '\"]'
+            decoration = ' [label=\"' .. i .. '\"]'
+         end
+         file:write(
+            '  '
+               .. self.node[nnma].index
+               .. ' -> '
+               .. self.node[nnmb].index
+               .. decoration
+               .. '\n'
+         )
+      end
+
+      file:write('\n')
+   end
+
+   file:write('}\n')
+
+end
+
+----------------------------------------------------------------------
+
 function DAG:updateOutput(input)
    self:putInOrder()
 
@@ -192,12 +240,14 @@ function DAG:updateOutput(input)
 end
 
 function DAG:updateGradInput(input, gradOutput)
-   assert(self.sorted, 'there has been a DAG structure change before a DAG:updateGradInput')
+   assert(self.sorted, 'There has been a DAG structure change before a DAG:updateGradInput')
 
    self:nestedApply(
       function(nnm, go)
+         local node = self.node[nnm]
+         node.gradOutput = go
          -- nnm:updateGradInput(self.node[nnm].input, go)
-         self:rethrowErrors(nnm, self.node[nnm].index, 'updateGradInput', self.node[nnm].input, go)
+         self:rethrowErrors(nnm, node.index, 'updateGradInput', self.node[nnm].input, go)
       end,
       self.outputModules, gradOutput
    )
@@ -243,14 +293,22 @@ end
 function DAG:accGradParameters(input, gradOutput, scale)
    scale = scale or 1
 
-   assert(self.sorted, 'there has been a DAG structure change before a DAG:accGradParameters')
+   assert(self.sorted, 'There has been a DAG structure change before a DAG:accGradParameters')
+
+   self:nestedApply(
+      function(nnm, go) self.node[nnm].gradOutput = go end,
+      self.outputModules, gradOutput
+   )
+
+   self:nestedApply(
+      function(nnm, i) self.node[nnm].input = i end,
+      self.inputModules, input
+   )
 
    for k = 1, #self.modules do
       local nnm = self.modules[k]
       local node = self.node[nnm]
       -- nnm:accGradParameters(node.input, node.gradOutput, scale)
-      self:rethrowErrors(nnm, k, 'accGradParameters', node.input, self:computeGradOutput(node.gradInputSucc), scale)
+      self:rethrowErrors(nnm, k, 'accGradParameters', node.input, node.gradOutput, scale)
    end
 end
-
-----------------------------------------------------------------------