refactor input model

src/Flux.jl

@@ -1,8 +1,8 @@
 module Flux
 
 using MacroTools, Lazy, Flow, Juno
-import Flow: graphm, syntax, prewalk, iscyclic, Constant, constant, isconstant,
+import Flow: graphm, syntax, prewalk, postwalk, iscyclic, Constant, constant,
-  value, inputs, thread!, value, inputs
+  isconstant, value, inputs, thread!, value, inputs, Split, Group
 import Juno: Tree, Row
 
 # Zero Flux Given

src/backend/tensorflow/tensorflow.jl

@@ -1,8 +1,8 @@
 module TF
 
 using ..Flux, Flow, TensorFlow, Juno
-import Flow: Constant, postwalk, value, inputs
+import Flow: Constant, postwalk, value, inputs, constant
-import Flux: accuracy
+import Flux: accuracy, spliceinputs, detuple
 import TensorFlow: RawTensor
 import Juno: info
 
@@ -20,9 +20,7 @@ graph{T<:AArray}(p::Flux.Param{T}) = Variable(p.x)
 function graph(model::Model, args...)
   g = Flux.graph(model)
   g ≠ nothing || error("No graph for $model")
-  g = Flow.mapconst(g) do x
+  g = spliceinputs(g, map(constant, args)...) |> detuple
-    isa(x, Flux.ModelInput) ? args[x.n] : x
-  end
   postwalk(g) do v
     vertex(graph(cvalue(v), cvalue.(inputs(v))...))
   end |> value

src/compiler/code.jl

@@ -14,7 +14,7 @@ end
 function makegraph(graph, args)
   @assert length(args) == 1
   mapconst(graph) do x
-    x == args[1] ? ModelInput(1) :
+    x == args[1] ? inputnode(1) :
     isa(x, Delay) ? :(Delay($(Expr(:quote, x.name)), self.$(x.name))) :
     x
   end

src/compiler/graph.jl

@@ -1,19 +1,30 @@
-# TODO: change the input approach
+immutable ModelInput end
-immutable ModelInput
-  n::Int
-end
 
-isinput(x) = isa(x, Constant) && isa(x.value, ModelInput)
+inputnode(n) = vertex(Split(n), constant(ModelInput()))
 
-bumpinput(i::ModelInput) = ModelInput(i.n + 1)
+# isinput(x) = isa(x, Constant) && value(x) == Input()
-bumpinput(x) = x
 
-bumpinputs(v::IVertex) = mapconst(bumpinput, v)
+# function bumpinput(v::IVertex)
+#   prewalk(v) do v
+#     isa(value(v), Split) && value(v[1]) == Input() ?
+#   end
+# end
 
-function spliceinputs(v::IVertex, inputs::IVertex...)
+function spliceinput(v::IVertex, input::IVertex)
-  postwalk(v) do v
+  prewalk(v) do v
-    isinput(value(v)) ?
+    value(v) == Constant(ModelInput()) ? input : v
-      inputs[value(v).value.n] :
+  end
-      v
+end
+
+spliceinputs(v::IVertex, inputs::Vertex...) =
+  spliceinput(v, vertex(Group(), inputs...))
+
+function detuple(v::IVertex)
+  prewalk(v) do v
+    if isa(value(v), Split) && isa(value(v[1]), Group)
+      v[1][value(v).n]
+    else
+      v
+    end
   end
 end

src/compiler/loops.jl

@@ -34,11 +34,11 @@ function atomise(model)
   end
 end
 
-hinput(n) = vertex(getindex, constant(ModelInput(1)), constant(n))
+hiddeninput(n) = vertex(Split(n), inputnode(1))
 
 function unroll!(delay::IVertex, n)
   prewalk!(delay[1]) do v
-    v === delay ? hinput(n) : v
+    v === delay ? hiddeninput(n) : v
   end
 end
 
@@ -51,23 +51,23 @@ function break!(g::IVertex)
     n = length(loops)+1
     push!(loops, unroll!(v, n))
     push!(defaults, get(value(v).default))
-    hinput(n)
+    hiddeninput(n)
   end
   cse(vertex(tuple, vertex(tuple, loops...), g)), defaults
 end
 
-function unroll(model, n)
+# function unroll(model, n)
-  graph, defaults = break!(atomise(model))
+#   graph, defaults = break!(atomise(model))
-  outputs = [spliceinputs(graph, vertex(tuple, map(constant, defaults)...), constant(ModelInput(1)))]
+#   outputs = [spliceinputs(graph, vertex(tuple, map(constant, defaults)...), inputnode(1))]
-  for i = 2:n
+#   for i = 2:n
-    push!(outputs, spliceinputs(graph, outputs[end][1], constant(ModelInput(i))))
+#     push!(outputs, spliceinputs(graph, outputs[end][1], constant(ModelInput(i))))
-  end
+#   end
-  state = outputs[end][1]
+#   state = outputs[end][1]
-  outputs = map(x -> x[2], outputs)
+#   outputs = map(x -> x[2], outputs)
-  vertex(tuple, state, vertex(tuple, outputs...))
+#   vertex(tuple, state, vertex(tuple, outputs...))
-end
+# end
 
-# r = Chain(Recurrent(30,10), Recurrent(10, 20))
+# r = Recurrent(10,10)
 # unroll(r, 1) |> syntax |> prettify |> display
 
 @net type Recurrent

src/layers/chain.jl

@@ -33,6 +33,6 @@ function Base.show(io::IO, c::Chain)
 end
 
 graph(s::Chain) =
-  foldl((v, m) -> vertex(m, v), constant(ModelInput(1)), s.layers)
+  foldl((v, m) -> vertex(m, v), constant(inputnode(1)), s.layers)
 
 shape(c::Chain, in) = c.shape