Merge branch 'master' into patch-2

Author: mzgubic

Project.toml

@@ -1,6 +1,6 @@
 name = "ChainRulesTestUtils"
 uuid = "cdddcdb0-9152-4a09-a978-84456f9df70a"
-version = "0.6.5"
+version = "0.6.9"
 
 [deps]
 ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
@@ -11,7 +11,7 @@ Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
-ChainRulesCore = "0.9.13"
+ChainRulesCore = "0.9.39"
 Compat = "3"
 FiniteDifferences = "0.12"
 julia = "1"

docs/src/index.md

@@ -117,7 +117,7 @@ Test.DefaultTestSet("test_scalar: relu at -0.5", Any[Test.DefaultTestSet("with t
 [`test_frule`](@ref) and [`test_rrule`](@ref) allow you to specify the tangents used for testing.
 This is done by passing in `x ⊢ Δx`, where `x` is the primal and `Δx` is the tangent, in the place of the primal inputs.
 If this is not done the tangent will be automatically generated via [`ChainRulesTestUtils.rand_tangent`](@ref).
-A special case of this is that if you specify it as `x ⊢ nothing` then finite differencing will not be used on that input.
+A special case of this is that if you specify it as `x ⊢ DoesNotExist()` then finite differencing will not be used on that input.
 Similarly, by setting the `output_tangent` keyword argument, you can specify the tangent for the primal output.
 
 This can be useful when the default provided [`ChainRulesTestUtils.rand_tangent`](@ref) doesn't produce the desired tangent for your type.

src/check_result.jl

@@ -29,6 +29,22 @@ check_equal(::Zero, x; kwargs...) = check_equal(zero(x), x; kwargs...)
 check_equal(x, ::Zero; kwargs...) = check_equal(x, zero(x); kwargs...)
 check_equal(x::Zero, y::Zero; kwargs...) = @test true
 
+# remove once https://github.com/JuliaDiff/ChainRulesTestUtils.jl/issues/113
+check_equal(x::DoesNotExist, y::Nothing; kwargs...) = @test true
+check_equal(x::Nothing, y::DoesNotExist; kwargs...) = @test true
+
+# Checking equality with `NotImplemented` reports `@test_broken` since the derivative has intentionally
+# not yet been implemented
+# `@test_broken x == y` yields more descriptive messages than `@test_broken false`
+check_equal(x::ChainRulesCore.NotImplemented, y; kwargs...) = @test_broken x == y
+check_equal(x, y::ChainRulesCore.NotImplemented; kwargs...) = @test_broken x == y
+# In this case we check for equality (messages etc. have to be equal)
+function check_equal(
+    x::ChainRulesCore.NotImplemented, y::ChainRulesCore.NotImplemented; kwargs...
+)
+    return @test x == y
+end
+
 """
     _can_pass_early(actual, expected; kwargs...)
 Used to check if `actual` is basically equal to `expected`, so we don't need to check deeper;
@@ -133,3 +149,20 @@ function _check_add!!_behaviour(acc, val; kwargs...)
     acc_mutated = deepcopy(acc)  # prevent this test changing others
     check_equal(add!!(acc_mutated, val), acc + val; kwargs...)
 end
+
+# Checking equality with `NotImplemented` reports `@test_broken` since the derivative has intentionally
+# not yet been implemented
+# `@test_broken x == y` yields more descriptive messages than `@test_broken false`
+function _check_add!!_behaviour(acc_mutated, acc::ChainRulesCore.NotImplemented; kwargs...)
+    return @test_broken acc_mutated == acc
+end
+function _check_add!!_behaviour(acc_mutated::ChainRulesCore.NotImplemented, acc; kwargs...)
+    return @test_broken acc_mutated == acc
+end
+# In this case we check for equality (messages etc. have to be equal)
+function _check_add!!_behaviour(
+    acc_mutated::ChainRulesCore.NotImplemented, acc::ChainRulesCore.NotImplemented;
+    kwargs...,
+)
+    return @test acc_mutated == acc
+end

src/generate_tangent.jl

@@ -54,6 +54,9 @@ rand_tangent(rng::AbstractRNG, x::Integer) = DoesNotExist()
 
 rand_tangent(rng::AbstractRNG, x::T) where {T<:Number} = randn(rng, T)
 
+# ref: https://github.com/JuliaLang/julia/issues/17629
+rand_tangent(rng::AbstractRNG, ::BigFloat) = big(randn(rng))
+
 rand_tangent(rng::AbstractRNG, x::StridedArray) = rand_tangent.(Ref(rng), x)
 
 function rand_tangent(rng::AbstractRNG, x::T) where {T<:Tuple}

src/testers.jl

@@ -75,7 +75,7 @@ end
 - `inputs` either the primal inputs `x`, or primals and their tangents: `x ⊢ ẋ`
    - `x`: input at which to evaluate `f` (should generally be set to an arbitary point in the domain).
    - `ẋ`: differential w.r.t. `x`, will be generated automatically if not provided
-     Non-differentiable arguments, such as indices, should have `ẋ` set as `nothing`.
+   Non-differentiable arguments, such as indices, should have `ẋ` set as `DoesNotExist()`.
 
 # Keyword Arguments
    - `output_tangent` tangent to test accumulation of derivatives against
@@ -113,7 +113,16 @@ function test_frule(
         Ω = f(deepcopy(xs)...; deepcopy(fkwargs)...)
         check_equal(Ω_ad, Ω; isapprox_kwargs...)
 
-        ẋs_is_ignored = ẋs .== nothing
+        # TODO: remove Nothing when https://github.com/JuliaDiff/ChainRulesTestUtils.jl/issues/113
+        ẋs_is_ignored = isa.(ẋs, Union{Nothing, DoesNotExist})
+        if any(ẋs .== nothing)
+            Base.depwarn(
+                "test_frule(f, k ⊢ nothing) is deprecated, use " *
+                "test_frule(f, k ⊢ DoesNotExist()) instead for non-differentiable ks",
+                :test_frule
+            )
+        end
+
         # Correctness testing via finite differencing.
         dΩ_fd = _make_jvp_call(fdm, (xs...) -> f(deepcopy(xs)...; deepcopy(fkwargs)...), Ω, xs, ẋs, ẋs_is_ignored)
         check_equal(dΩ_ad, dΩ_fd; isapprox_kwargs...)
@@ -133,7 +142,7 @@ end
 - `inputs` either the primal inputs `x`, or primals and their tangents: `x ⊢ ẋ`
     - `x`: input at which to evaluate `f` (should generally be set to an arbitary point in the domain).
     - `x̄`: currently accumulated cotangent, will be generated automatically if not provided
-      Non-differentiable arguments, such as indices, should have `x̄` set as `nothing`.
+    Non-differentiable arguments, such as indices, should have `x̄` set as `DoesNotExist()`.
 
 # Keyword Arguments
  - `output_tangent` the seed to propagate backward for testing (techncally a cotangent).
@@ -181,11 +190,24 @@ function test_rrule(
         @test ∂self === NO_FIELDS  # No internal fields
 
         # Correctness testing via finite differencing.
-        x̄s_is_dne = accumulated_x̄ .== nothing
+        # TODO: remove Nothing when https://github.com/JuliaDiff/ChainRulesTestUtils.jl/issues/113
+        x̄s_is_dne = isa.(accumulated_x̄, Union{Nothing, DoesNotExist})
+        if any(accumulated_x̄ .== nothing)
+            Base.depwarn(
+                "test_rrule(f, k ⊢ nothing) is deprecated, use " *
+                "test_rrule(f, k ⊢ DoesNotExist()) instead for non-differentiable ks",
+                :test_rrule
+            )
+        end
+
         x̄s_fd = _make_j′vp_call(fdm, (xs...) -> f(xs...; fkwargs...), ȳ, xs, x̄s_is_dne)
         for (accumulated_x̄, x̄_ad, x̄_fd) in zip(accumulated_x̄, x̄s_ad, x̄s_fd)
-            if accumulated_x̄ === nothing  # then we marked this argument as not differentiable
+            if accumulated_x̄ isa Union{Nothing, DoesNotExist}  # then we marked this argument as not differentiable # TODO remove once #113
                 @assert x̄_fd === nothing  # this is how `_make_j′vp_call` works
+                x̄_ad isa Zero && error(
+                    "The pullback in the rrule for $f function should use DoesNotExist()" *
+                    " rather than Zero() for non-perturbable arguments."
+                )
                 @test x̄_ad isa DoesNotExist  # we said it wasn't differentiable.
             else
                 x̄_ad isa AbstractThunk && check_inferred && _test_inferred(unthunk, x̄_ad)

test/check_result.jl

@@ -33,7 +33,7 @@ end
 
     @testset "check_equal" begin
 
-        @testset "possive cases" begin
+        @testset "positive cases" begin
             check_equal(1.0, 1.0)
             check_equal(1.0 + im, 1.0 + im)
             check_equal(1.0, 1.0+1e-10)  # isapprox _behaviour
@@ -46,6 +46,10 @@ end
 
             check_equal(@thunk(10*0.1*[[1.0], [2.0]]), [[1.0], [2.0]])
 
+            check_equal(@not_implemented(""), rand(3))
+            check_equal(rand(3), @not_implemented(""))
+            check_equal(@not_implemented("a"), @not_implemented("a"))
+
             check_equal(
                 Composite{Tuple{Float64, Float64}}(1.0, 2.0),
                 Composite{Tuple{Float64, Float64}}(1.0, 2.0)
@@ -92,6 +96,8 @@ end
             @test fails(()->check_equal([[1.0], [2.0]], [[1.1], [2.0]]))
 
             @test fails(()->check_equal(@thunk(10*[[1.0], [2.0]]), [[1.0], [2.0]]))
+
+            @test fails(()->check_equal(@not_implemented("a"), @not_implemented("b")))
         end
         @testset "type negative" begin
             @test fails() do  # these have different primals so should not be equal

test/generate_tangent.jl

@@ -17,6 +17,7 @@ end
         (true, DoesNotExist),
         (4, DoesNotExist),
         (5.0, Float64),
+        (big(5.0), BigFloat),
         (5.0 + 0.4im, Complex{Float64}),
         (randn(Float32, 3), Vector{Float32}),
         (randn(Complex{Float64}, 2), Vector{Complex{Float64}}),

test/meta_testing_tools.jl

@@ -121,7 +121,10 @@ end
         @testset "Single Test" begin
             fails = nonpassing_results(()->@test false)
             @test length(fails) === 1
-            @test fails[1].orig_expr == false
+            # Julia 1.6 return a `String`, not an `Expr`.
+            # Always calling  `string` on it gives gives consistency regardless of version.
+            # https://github.com/JuliaLang/julia/pull/37809
+            @test string(fails[1].orig_expr) == string(false)
         end
 
         @testset "Single Testset" begin
@@ -132,8 +135,12 @@ end
                 end
             end
             @test length(fails) === 2
-            @test fails[1].orig_expr == :(false==true)
-            @test fails[2].orig_expr == :(true==false)
+
+            # Julia 1.6 return a `String`, not an `Expr`.
+            # Always calling  `string` on it gives gives consistency regardless of version.
+            # https://github.com/JuliaLang/julia/pull/37809
+            @test string(fails[1].orig_expr) == string(:(false == true))
+            @test string(fails[2].orig_expr) == string(:(true == false))
         end
 
 

test/testers.jl

@@ -14,7 +14,6 @@ f_noninferrable_pullback(x) = x
 f_noninferrable_thunk(x, y) = x + y
 f_inferrable_pullback_only(x) = x > 0 ? Float64(x) : Float32(x)
 
-
 function finplace!(x; y = [1])
     y[1] = 2
     x .*= y[1]
@@ -507,4 +506,24 @@ end
         end
         test_rrule(rev_trouble, (3, 3.0) ⊢ Composite{Tuple{Int, Float64}}(Zero(), 1.0))
     end
+
+    @testset "error message about incorrectly using Zero()" begin
+        foo(a, i) = a[i]
+        function ChainRulesCore.rrule(::typeof(foo), a, i)
+            function foo_pullback(Δy)
+                da = zeros(size(a))
+                da[i] = Δy
+                return NO_FIELDS, da, Zero()
+            end
+            return foo(a, i), foo_pullback
+        end
+        @test errors(() -> test_rrule(foo, [1.0, 2.0, 3.0], 2), "should use DoesNotExist()")
+    end
+
+    @testset "NotImplemented" begin
+        f_notimplemented(x, y) = (x + y, x - y)
+        @scalar_rule f_notimplemented(x, y) (@not_implemented(""), 1) (1, -1)
+        test_frule(f_notimplemented, randn(), randn())
+        test_rrule(f_notimplemented, randn(), randn())
+    end
 end