X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?p=dagnn.git;a=blobdiff_plain;f=dagnn.lua;h=de9d29b8d3e15c2d0575144f29ee0e1ed1a881de;hp=8a02cc6dbabfa701bf4a61cf3c7b67b43d05f691;hb=56a476ee19396d0e7f186b238dc7d013000acb59;hpb=31dc42fc93ed12491ceb10ef3bfc4296878380ee diff --git a/dagnn.lua b/dagnn.lua index 8a02cc6..de9d29b 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 + + 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 . + +]]-- + require 'torch' require 'nn' @@ -6,47 +25,103 @@ local DAG, parent = torch.class('nn.DAG', 'nn.Container') function DAG:__init() parent.__init(self) - -- Nodes are indexed by the module they encompass + -- Nodes are indexed by the module they contain self.node = { } end +-- 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) + if torch.type(t) == 'table' then + local result = {} + for k, s in pairs(t) do + result[k] = self:nestedApply(f, s, args and args[k]) + end + return result + else + return f(t, args) + end +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) - self.sorted = nil - self:createNode(nnma) - self:createNode(nnmb) - table.insert(self.node[nnmb].pred, nnma) - table.insert(self.node[nnma].succ, nnmb) +function DAG:putInOrder() + if self.sorted then + return + end + + 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 + for _, nnmb in pairs(node.succ) do + if distance[nnma] and (not distance[nnmb] or distance[nnmb] < distance[nnma] + 1) then + distance[nnmb] = distance[nnma] + 1 + nc = nc + 1 + end + end + end + until nc == 0 + + self.sorted = { } + for m, d in pairs(distance) do + table.insert(self.sorted, { distance = d, nnm = m }) + end + + table.sort(self.sorted, function(a, b) return a.distance < b.distance end) + + for i, a in ipairs(self.sorted) do self.sorted[i] = a.nnm end end --- Apply f on t recursively; use the corresponding a1 and a2 elements --- (i.e. same keys) as second and third parameters to f when --- available; return the results from f, organized in a similarly --- nested table. -function DAG:nestApply(f, t, a1, a2) - if torch.type(t) == 'table' then - local result = {} - for k, s in pairs(t) do - result[k] = self:nestApply(f, s, a1 and a1[k], a2 and a2[k]) +function DAG:updateGradOutput(node) + local gradInputSucc = node.gradInputSucc + if #gradInputSucc == 1 then + node.gradOutput = gradInputSucc[1] + elseif #gradInputSucc > 1 then + if node.gradOutput then + node.gradOutput:resize(gradInputSucc[1]):copy(gradInputSucc[1]) + else + node.gradOutput = gradInputSucc[1]:clone() end - return result - else - return f(t, a1, a2) + for k = 2, #gradInputSucc do + node.gradOutput:add(gradInputSucc[k]) + end + end +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:nestApply( + self:nestedApply( function(nnm) if #self.node[nnm].succ == 0 then error('Input modules must have outgoing edges.') @@ -62,7 +137,7 @@ end function DAG:setOutput(o) self.sorted = nil self.outputModules = o - self:nestApply( + self:nestedApply( function(nnm) if #self.node[nnm].pred == 0 then error('Output module must have incoming edges.') @@ -75,56 +150,63 @@ function DAG:setOutput(o) ) end -function DAG:putInOrder() - if self.sorted then - return +function DAG:print() + self:putInOrder() + + for i, d in ipairs(self.sorted) do + print('#' .. i .. ' -> ' .. torch.type(d)) end +end - -- First, we sort the nodes according to the DAG order +---------------------------------------------------------------------- - local distance = {} +function DAG:saveDot(filename) + local file = (filename and io.open(filename, 'w')) or io.stdout - self:nestApply(function(m) distance[m] = 1 end, self.inputModules) + file:write('digraph {\n') - local nc + file:write('\n') - repeat - nc = 0 - for nnma, node in pairs(self.node) do - for _, nnmb in pairs(node.succ) do - if distance[nnma] and (not distance[nnmb] or distance[nnmb] < distance[nnma] + 1) then - distance[nnmb] = distance[nnma] + 1 - nc = nc + 1 - end + 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 - until nc == 0 - self.sorted = { } - for m, d in pairs(distance) do - table.insert(self.sorted, { distance = d, nnm = m }) + file:write('\n') end - table.sort(self.sorted, function(a, b) return a.distance < b.distance end) + file:write('}\n') - for i, a in ipairs(self.sorted) do self.sorted[i] = a.nnm end end -function DAG:print() - self:putInOrder() - - for i, d in ipairs(self.sorted) do - print('#' .. i .. ' -> ' .. torch.type(d)) - end -end +---------------------------------------------------------------------- function DAG:updateOutput(input) self:putInOrder() - self:nestApply( + self:nestedApply( function(nnm, i) self.node[nnm].input = i - nnm:updateOutput(i) + self:rethrowErrors(nnm, self.node[nnm].index, 'updateOutput', i) end, self.inputModules, input @@ -143,40 +225,31 @@ function DAG:updateOutput(input) end end node.input = i - nnm:updateOutput(i) + self:rethrowErrors(nnm, self.node[nnm].index, 'updateOutput', i) end end - self.output = self:nestApply(function(m) return m.output end, self.outputModules) + self.output = self:nestedApply( + function(m) return m.output end, + self.outputModules + ) 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:nestApply( - function(nnm, go) nnm:updateGradInput(self.node[nnm].input, go) end, + self:nestedApply( + function(nnm, go) + local node = self.node[nnm] + node.gradOutput = go + self:rethrowErrors(nnm, node.index, 'updateGradInput', self.node[nnm].input, go) + end, self.outputModules, gradOutput ) - self:nestApply( + self:nestedApply( function(nnm, i) self.node[nnm].input = i end, self.inputModules, input ) @@ -188,10 +261,11 @@ function DAG:updateGradInput(input, gradOutput) for k = #self.sorted, 1, -1 do local nnm = self.sorted[k] local node = self.node[nnm] - local pred, gradInputSucc = node.pred, node.gradInputSucc + local pred = node.pred - if #gradInputSucc > 0 then - nnm:updateGradInput(node.input, self:computeGradInput(gradInputSucc)) + if #node.gradInputSucc > 0 then + self:updateGradOutput(node) + self:rethrowErrors(nnm, self.node[nnm].index, 'updateGradInput', node.input, node.gradOutput) end -- We fill the gradInputSucc of our predecessors @@ -207,9 +281,29 @@ function DAG:updateGradInput(input, gradOutput) end end - self.gradInput = self:nestApply(function(m) return m.gradInput end, self.inputModules) + self.gradInput = self:nestedApply(function(m) return m.gradInput end, self.inputModules) return self.gradInput end -return DAG +function DAG:accGradParameters(input, gradOutput, scale) + scale = scale or 1 + + 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] + self:rethrowErrors(nnm, k, 'accGradParameters', node.input, node.gradOutput, scale) + end +end