prepare for repo change

Author: jrevels

.travis.yml

@@ -9,7 +9,7 @@ notifications:
   email: false
 script:
  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
- - julia -e 'Pkg.clone(pwd()); Pkg.build("ReverseDiffPrototype"); Pkg.test("ReverseDiffPrototype"; coverage=true)'
+ - julia -e 'Pkg.clone(pwd()); Pkg.build("ReverseDiff"); Pkg.test("ReverseDiff"; coverage=true)'
 after_success:
   # push coverage results to Coveralls
-  - julia -e 'cd(Pkg.dir("ReverseDiffPrototype")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'
+  - julia -e 'cd(Pkg.dir("ReverseDiff")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'

LICENSE.md

@@ -1,4 +1,4 @@
-The ReverseDiffPrototype.jl package is licensed under the MIT "Expat" License:
+The ReverseDiff.jl package is licensed under the MIT "Expat" License:
 
 > Copyright (c) 2016: Jarrett Revels, John Pearson
 >

README.md

@@ -1,5 +1,7 @@
-# ReverseDiffPrototype
+# ReverseDiff
 
-This is a prototype Julia implementation of reverse mode AD.
+A Julia implementation of reverse mode AD.
 
-[![Build Status](https://travis-ci.org/jrevels/ReverseDiffPrototype.jl.svg?branch=master)](https://travis-ci.org/jrevels/ReverseDiffPrototype.jl)
+Documentation coming soon!
+
+[![Build Status](https://travis-ci.org/jrevels/ReverseDiff.jl.svg?branch=master)](https://travis-ci.org/jrevels/ReverseDiff.jl)

appveyor.yml

@@ -28,7 +28,7 @@ build_script:
 # Need to convert from shallow to complete for Pkg.clone to work
   - IF EXIST .git\shallow (git fetch --unshallow)
   - C:\projects\julia\bin\julia -e "versioninfo();
-      Pkg.clone(pwd(), \"ReverseDiffPrototype\"); Pkg.build(\"ReverseDiffPrototype\")"
+      Pkg.clone(pwd(), \"ReverseDiff\"); Pkg.build(\"ReverseDiff\")"
 
 test_script:
-  - C:\projects\julia\bin\julia -e "Pkg.test(\"ReverseDiffPrototype\")"
+  - C:\projects\julia\bin\julia -e "Pkg.test(\"ReverseDiff\")"

benchmark/benchmark.jl

@@ -1,40 +1,40 @@
-using ReverseDiffPrototype
-
-const RDP = ReverseDiffPrototype
+using ReverseDiff
 
 ####################################################################
 
 function grad_benchmark_driver(f, x)
     println("benchmarking ∇$(f)(x) on $(length(x)) elements...")
 
     out = zeros(x)
-    opts = RDP.Options(out, RDP.Tape(), x)
+    opts = ReverseDiff.Options(x, ReverseDiff.Tape())
     tp = opts.tape
-    xt = opts.data
+    xt = opts.state
 
     # warmup
-    RDP.seed!(f(xt))
-    RDP.backprop!(tp)
+    ReverseDiff.track!(xt, x, tp)
+    ReverseDiff.seed!(f(xt))
+    ReverseDiff.reverse_pass!(tp)
     empty!(tp)
-    RDP.gradient!(out, f, x, opts)
+    ReverseDiff.gradient!(out, f, x, opts)
     empty!(tp)
 
     # actual
+    ReverseDiff.track!(xt, x, tp)
     gc()
-    @time RDP.seed!(f(xt))
+    @time ReverseDiff.seed!(f(xt))
     gc()
-    @time RDP.backprop!(tp)
+    @time ReverseDiff.reverse_pass!(tp)
     empty!(tp)
     gc()
-    @time RDP.gradient!(out, f, x, opts)
+    @time ReverseDiff.gradient!(out, f, x, opts)
     empty!(tp)
 
     println("done.")
 end
 
 ####################################################################
 
-rosenbrock(x) = sum(map(RDP.@forward((i, j) -> (1 - j)^2 + 100*(i - j^2)^2), x[2:end], x[1:end-1]))
+rosenbrock(x) = sum(map(ReverseDiff.@forward((i, j) -> (1 - j)^2 + 100*(i - j^2)^2), x[2:end], x[1:end-1]))
 
 grad_benchmark_driver(rosenbrock, rand(100000))
 
@@ -75,15 +75,15 @@ grad_benchmark_driver(matrix_test, collect(1.0:(2n^2 + n)))
 
 relu(x) = log.(1.0 .+ exp(x))
 
-RDP.@forward sigmoid(n) = 1. / (1. + exp(-n))
+ReverseDiff.@forward sigmoid(n) = 1. / (1. + exp(-n))
 
 function neural_net(w1, w2, w3, x1)
     x2 = relu(w1 * x1)
     x3 = relu(w2 * x2)
     return sigmoid(dot(w3, x3))
 end
 
-neural_net_grads!(outputs, inputs) = RDP.gradient!(outputs, neural_net, inputs)
+neural_net_grads!(outputs, inputs) = ReverseDiff.gradient!(outputs, neural_net, inputs)
 
 inputs = (randn(10,10), randn(10,10), randn(10), rand(10))
 outputs = map(similar, inputs)

src/ReverseDiffPrototype.jl src/ReverseDiff.jl

@@ -1,4 +1,4 @@
-module ReverseDiffPrototype
+module ReverseDiff
 
 using DiffBase
 using DiffBase: DiffResult

src/api/gradients.jl

@@ -47,7 +47,7 @@ function gradient!(out, f, x, opts::Options = Options(x, eltype(out)))
     return out
 end
 
-function gradient!(outs::Tuple, f, xs::Tuple, opts::Options = Options(xs, map(eltype, outs)))
+function gradient!(outs::Tuple, f, xs::Tuple, opts::Options = Options(xs, eltype(first(outs))))
     xts, tp = opts.state, opts.tape
     track!(xts, xs, tp)
     yt = f(xts...)

src/api/jacobians.jl

@@ -22,7 +22,7 @@ function jacobian(f, xs::Tuple, opts::Options = Options(xs))
     outs = construct_jacobian_output(yt, xts)
     jacobian_reverse_pass!(outs, yt, xts, tp)
     empty!(tp)
-    return out
+    return outs
 end
 
 # jacobian! #
@@ -38,7 +38,7 @@ function jacobian!(out, f, x, opts::Options = Options(x, eltype(out)))
     return out
 end
 
-function jacobian!(outs::Tuple, f, xs::Tuple, opts::Options = Options(xs, map(eltype, outs)))
+function jacobian!(outs::Tuple, f, xs::Tuple, opts::Options = Options(xs, eltype(first(outs))))
     xts, tp = opts.state, opts.tape
     track!(xts, xs, tp)
     yt = f(xts...)
@@ -140,7 +140,7 @@ function jacobian_reverse_pass!(out, yt, xt, tp::Tape)
     return out
 end
 
-function jacobian_reverse_pass!(outs::Tuple, yt, xts::Tuple, tp)
+function jacobian_reverse_pass!(outs::Tuple, yt, xts::Tuple, tp::Tape)
     for i in eachindex(outs)
         jacobian_reverse_pass!(outs[i], yt, xts[i], tp)
     end

src/derivatives/elementwise.jl

@@ -187,10 +187,6 @@ end
 # broadcast #
 #-----------#
 
-function special_reverse_step!(::typeof(broadcast), input::AbstractArray, output, duals)
-    return special_reverse_step!(map, input, output, duals)
-end
-
 function special_reverse_step!{A,B}(::typeof(broadcast), inputs::Tuple{A,B}, output, duals)
     a, b = inputs
     if size(a) == size(b)
@@ -202,8 +198,12 @@ function special_reverse_step!{A,B}(::typeof(broadcast), inputs::Tuple{A,B}, out
     return nothing
 end
 
-function special_reverse_step!(::typeof(broadcast), input::Number, output, duals)
-    broadcast_adjoint_reduce!(input, output, duals, 1)
+function special_reverse_step!(::typeof(broadcast), input, output, duals)
+    if size(input) == size(output)
+        special_reverse_step!(map, input, output, duals)
+    else
+        broadcast_adjoint_reduce!(input, output, duals, 1)
+    end
     return nothing
 end
 
@@ -213,10 +213,10 @@ end
 # Base.mapreducedim, but that strategy is less cache efficient and more complicated to
 # implement.
 function broadcast_adjoint_reduce!{T,N}(input::AbstractArray, output::AbstractArray{T,N}, duals, p)
-    dims = (size(input, i) != size(duals, i) ? 1 : size(duals, i) for i in 1:ndims(duals))
-    max_index = CartesianIndex((dims...)::NTuple{N,Int})
-    for i in CartesianRange(size(input))
-        increment_adjoint!(input[min(max_index, i)], adjoint(output[i]) * partials(duals[i], p))
+    max_input_index = CartesianIndex(ntuple(i -> size(input, i), N)::NTuple{N,Int})
+    output_index_range = CartesianRange(size(output))
+    for i in output_index_range
+        increment_adjoint!(input[min(max_input_index, i)], adjoint(output[i]) * partials(duals[i], p))
     end
     return nothing
 end

src/derivatives/macros.jl

@@ -26,17 +26,17 @@ function annotate_func_expr(typesym, expr)
             return quote
                 $expr
                 @inline function $(old_name_and_types)($(args_signature...))
-                    return ReverseDiffPrototype.$(typesym)($(hidden_name))($(args_signature...))
+                    return ReverseDiff.$(typesym)($(hidden_name))($(args_signature...))
                 end
             end
         elseif isa(lhs, Symbol) # variable assignment site
-            expr.args[2] = :(ReverseDiffPrototype.$(typesym)($(expr.args[2])))
+            expr.args[2] = :(ReverseDiff.$(typesym)($(expr.args[2])))
             return expr
         else
             error("failed to apply $typesym to expression $expr")
         end
     else # call site
-        return :(ReverseDiffPrototype.$(typesym)($expr))
+        return :(ReverseDiff.$(typesym)($expr))
     end
 end
 

test/TapeTests.jl

@@ -1,6 +1,6 @@
 module TapeTests
 
-using ReverseDiffPrototype, Base.Test
+using ReverseDiff, Base.Test
 
 include("utils.jl")
 
@@ -24,7 +24,7 @@ tn = TapeNode(+, (x, y, k), z, c)
 
 tp = Tape()
 ntp = Nullable(tp)
-RDP.record!(ntp, +, (x, y, k), z, c)
+ReverseDiff.record!(ntp, +, (x, y, k), z, c)
 tp1 = first(tp)
 @test tp1 == tn
 @test tp1.inputs[1] !== x
@@ -34,20 +34,20 @@ tp1 = first(tp)
 @test tp1.cache === c
 
 ntp = Nullable{Tape}()
-RDP.record!(ntp, +, (x, y, k), z, c)
+ReverseDiff.record!(ntp, +, (x, y, k), z, c)
 @test ntp === Nullable{Tape}()
 
 t = Tracked(1)
 x = [t, t]
-@test RDP.capture(t) === t
+@test ReverseDiff.capture(t) === t
 
-cx = RDP.capture(x)
+cx = ReverseDiff.capture(x)
 @test cx !== x
 @test cx == x
 @test cx[1] === x[1]
 @test cx[2] === x[2]
 
-cs = RDP.capture((x, t, x))
+cs = ReverseDiff.capture((x, t, x))
 @test cs[1] !== x
 @test cs[1] == x
 @test cs[1][1] === x[1]

test/TrackedTests.jl

@@ -1,6 +1,6 @@
 module TrackedTests
 
-using ReverseDiffPrototype, Base.Test
+using ReverseDiff, Base.Test
 
 include("utils.jl")
 
@@ -18,7 +18,7 @@ tp = Tape()
 ntp = Nullable(tp)
 
 @test value(a) === a
-@test !(RDP.hastape(a))
+@test !(ReverseDiff.hastape(a))
 
 at = Tracked(a)
 @test valtype(at) === typeof(a)
@@ -28,7 +28,7 @@ at = Tracked(a)
 @test value(at) === at.value === a
 @test adjoint(at) === at.adjoint === zero(a)
 @test tape(at) === at.tape === Nullable{Tape}()
-@test !(RDP.hastape(at))
+@test !(ReverseDiff.hastape(at))
 
 bt = Tracked(b, Int)
 @test valtype(bt) === typeof(b)
@@ -38,7 +38,7 @@ bt = Tracked(b, Int)
 @test value(bt) === bt.value === b
 @test adjoint(bt) === bt.adjoint === zero(Int)
 @test tape(bt) === bt.tape === Nullable{Tape}()
-@test !(RDP.hastape(bt))
+@test !(ReverseDiff.hastape(bt))
 
 ct = Tracked(c, Int, ntp)
 @test valtype(ct) === typeof(c)
@@ -48,7 +48,7 @@ ct = Tracked(c, Int, ntp)
 @test value(ct) === ct.value === c
 @test adjoint(ct) === ct.adjoint === zero(Int)
 @test get(tape(ct)) === get(ct.tape) === tp === get(ntp)
-@test RDP.hastape(ct)
+@test ReverseDiff.hastape(ct)
 
 @test tape(at) === tape(bt) === Nullable{Tape}()
 @test tape(at, bt) === tape(bt, at)

test/UtilsTests.jl

@@ -1,6 +1,6 @@
 module UtilsTests
 
-using ReverseDiffPrototype, Base.Test
+using ReverseDiff, Base.Test
 
 include("utils.jl")
 
@@ -107,17 +107,17 @@ xt, yt = track(x, tp), track(y, tp)
 @test value(yt) == y
 
 x_sim, y_sim = similar(x), similar(y)
-RDP.value!(x_sim, xt)
-RDP.value!(y_sim, yt)
+ReverseDiff.value!(x_sim, xt)
+ReverseDiff.value!(y_sim, yt)
 @test x_sim == x
 @test y_sim == y
 
 @test all(adjoint(xt) .== zero(first(x)))
 @test all(adjoint(yt) .== zero(first(y)))
 
 x_sim, y_sim = similar(x), similar(y)
-RDP.adjoint!(x_sim, xt)
-RDP.adjoint!(y_sim, yt)
+ReverseDiff.adjoint!(x_sim, xt)
+ReverseDiff.adjoint!(y_sim, yt)
 @test all(x_sim .== zero(first(x)))
 @test all(y_sim .== zero(first(y)))
 
@@ -140,22 +140,22 @@ RDP.adjoint!(y_sim, yt)
 tp = Tape()
 ntp = Nullable(tp)
 
-@test tracked_is(RDP.seed!(Tracked(1, 0, ntp)), Tracked(1, 1, ntp))
+@test tracked_is(ReverseDiff.seed!(Tracked(1, 0, ntp)), Tracked(1, 1, ntp))
 
 node = TapeNode(+, (Tracked(2, ntp), Tracked(1, ntp)), Tracked(3, ntp), nothing)
-@test tracked_is(RDP.seed!(node).outputs, Tracked(3, 1, ntp))
+@test tracked_is(ReverseDiff.seed!(node).outputs, Tracked(3, 1, ntp))
 
-@test tracked_is(RDP.unseed!(Tracked(1, 1, ntp)), Tracked(1, 0, ntp))
+@test tracked_is(ReverseDiff.unseed!(Tracked(1, 1, ntp)), Tracked(1, 0, ntp))
 
 node = TapeNode(+, (Tracked(2, 2, ntp), Tracked(1, 3, ntp)), Tracked(3, 4, ntp), nothing)
-RDP.unseed!(node)
+ReverseDiff.unseed!(node)
 @test adjoint(node.inputs[1]) === 0
 @test adjoint(node.inputs[2]) === 0
 @test adjoint(node.outputs) === 0
 
 tp2 = [TapeNode(+, (Tracked(2, 2, ntp), Tracked(1, 3, ntp)), Tracked(3, 4, ntp), nothing),
        TapeNode(+, Tracked(1.0, 3.0, ntp), (Tracked(51.4, 3.1, ntp), Tracked(3, 4, ntp)), nothing)]
-RDP.unseed!(tp2)
+ReverseDiff.unseed!(tp2)
 @test adjoint(tp2[1].inputs[1]) === 0
 @test adjoint(tp2[1].inputs[2]) === 0
 @test adjoint(tp2[1].outputs) === 0
@@ -173,26 +173,26 @@ genarr = () -> [Tracked(rand(), rand(), ntp) for i in 1:3]
 
 x, y = genarr(), genarr()
 xadj, yadj = adjoint(x), adjoint(y)
-RDP.extract_and_decrement_adjoint!(x, y)
+ReverseDiff.extract_and_decrement_adjoint!(x, y)
 @test adjoint(x) == (xadj - yadj)
 
 x, y = genarr(), genarr()
 xadj, yadj = adjoint(x), adjoint(y)
-RDP.extract_and_increment_adjoint!(x, y)
+ReverseDiff.extract_and_increment_adjoint!(x, y)
 @test adjoint(x) == (xadj + yadj)
 
 x, y = genarr(), rand(3)
 xadj = adjoint(x)
-RDP.increment_adjoint!(x, y)
+ReverseDiff.increment_adjoint!(x, y)
 @test adjoint(x) == (xadj + y)
 
 x = genarr()
 xadj = adjoint(x)
-RDP.increment_adjoint!(x, 3)
+ReverseDiff.increment_adjoint!(x, 3)
 @test adjoint(x) == (xadj + 3)
 
 k = Tracked(1, 3, ntp)
-RDP.increment_adjoint!(k, 3)
+ReverseDiff.increment_adjoint!(k, 3)
 @test tracked_is(k, Tracked(1, 6, ntp))
 
 ############################################################################################