Initial commit.

Author: abeschneider

BPTS.lua

@@ -0,0 +1,54 @@
+--[[--
+In backpropagation through structure (BPTS) [see: "Learning task-dependent distributed representations by backpropagation 
+through structure" (Goller and Kuchler, 1996)] a tree is created from the input, with a single encoder is cloned per node. 
+Forward propagation is carried out by taking the input of the leafs and concatenating them in the parent
+node (similar to RAAM). Thus for the tree:
+
+		  A
+		/	\
+	   B     C
+	   
+A's input is the output of B and C concatenated together. The error is calculated for the top node (given
+a criterion), with backpropagation carried out by splitting the error across the children.
+--]]--
+
+local BPTS = torch.class("BPTS")
+
+require 'nn'
+require 'Tree'
+
+
+function BPTS.createNode(encoder, children)
+	local seq = nn.Sequential()
+	
+	-- set children as input to this node
+	local parallel = nn.ParallelTable()	
+	for _, child in ipairs(children) do			
+		parallel:add(child)
+	end
+	seq:add(parallel)
+		
+	-- concatenate their values
+	seq:add(nn.JoinTable(1))		
+	
+	local sharedEncoder = encoder:clone("weight", "bias")
+	seq:add(sharedEncoder)
+	return seq
+end
+
+function BPTS.createFromTree(tree, encoder)
+	if tree:isLeaf() then
+		-- leafs' inputs are their values
+		return nn.Identity(), tree.value
+	else
+		local children = {}
+		local values = {}
+		for _, child in ipairs(tree.children) do
+			mod, value = BPTS.createFromTree(child, encoder)			
+			table.insert(children, mod)
+			table.insert(values, value)
+		end
+		
+		return BPTS.createNode(encoder, children), values
+	end
+end

testBPTS.lua

@@ -0,0 +1,48 @@
+require 'BPTS'
+
+-- create an arbritrary dictionary
+function createDictionary(size)
+	local dict = {}
+	dict["A"] = torch.rand(size)
+	dict["B"] = torch.rand(size)
+	dict["C"] = torch.rand(size)
+	dict["D"] = torch.rand(size)
+	dict["E"] = torch.rand(size)
+	dict["F"] = torch.rand(size)
+	return dict	
+end
+
+function createEncoder(encodingSize)
+	local encoder = nn.Sequential()
+	encoder:add(nn.Linear(2*encodingSize, encodingSize))
+	encoder:add(nn.Tanh())	
+	return encoder
+end
+
+function main()
+	torch.manualSeed(42)
+	local encodingSize = 5
+
+	-- parse a manually create tree
+	local tree = Tree.parse("(root A (childA (childB B C) D))", createDictionary(encodingSize))
+
+	-- create the encoder to be used at each leaf
+	local encoder = createEncoder(encodingSize)
+
+	-- create the network using the tree
+	local bpts, input = BPTS.createFromTree(tree, encoder)
+	local output = torch.Tensor{1, 0, 0, 0, 0}
+	local criterion = nn.MSECriterion()
+
+	-- do a basic functionality test
+	criterion:forward(bpts:forward(input), output)
+	bpts:zeroGradParameters()
+	bpts:backward(input, criterion:backward(bpts.output, output))
+	
+	-- however, no simple way to test the gradient (below will fail)
+	-- local err = Jacobian.testJacobian(bpts, input)
+	-- print("error: ", err)	
+end
+
+
+main()