Prepare pushforward and pullback with seed (#181)

gdalle · web-flow · commit a22ccc7eb0da · 2024-04-16T14:07:27.000+02:00
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceChainRulesCoreExt/DifferentiationInterfaceChainRulesCoreExt.jl b/DifferentiationInterface/ext/DifferentiationInterfaceChainRulesCoreExt/DifferentiationInterfaceChainRulesCoreExt.jl
@@ -18,7 +18,7 @@ DI.mode(::AutoReverseChainRules) = ADTypes.AbstractReverseMode
 
 ## Pullback
 
-DI.prepare_pullback(f, ::AutoReverseChainRules, x) = NoPullbackExtras()
+DI.prepare_pullback(f, ::AutoReverseChainRules, x, dy) = NoPullbackExtras()
 
 function DI.value_and_pullback_split(
     f, backend::AutoReverseChainRules, x, ::NoPullbackExtras
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceDiffractorExt/DifferentiationInterfaceDiffractorExt.jl b/DifferentiationInterface/ext/DifferentiationInterfaceDiffractorExt/DifferentiationInterfaceDiffractorExt.jl
@@ -12,7 +12,7 @@ DI.mode(::AutoChainRules{<:DiffractorRuleConfig}) = ADTypes.AbstractForwardMode
 
 ## Pushforward
 
-DI.prepare_pushforward(f, ::AutoDiffractor, x) = NoPushforwardExtras()
+DI.prepare_pushforward(f, ::AutoDiffractor, x, dx) = NoPushforwardExtras()
 
 function DI.pushforward(f, ::AutoDiffractor, x, dx, ::NoPushforwardExtras)
     # code copied from Diffractor.jl
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceEnzymeExt/forward_onearg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceEnzymeExt/forward_onearg.jl
@@ -1,6 +1,6 @@
 ## Pushforward
 
-DI.prepare_pushforward(f, ::AutoForwardEnzyme, x) = NoPushforwardExtras()
+DI.prepare_pushforward(f, ::AutoForwardEnzyme, x, dx) = NoPushforwardExtras()
 
 function DI.value_and_pushforward(
     f, backend::AutoForwardEnzyme, x, dx, ::NoPushforwardExtras
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceEnzymeExt/forward_twoarg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceEnzymeExt/forward_twoarg.jl
@@ -1,6 +1,6 @@
 ## Pushforward
 
-DI.prepare_pushforward(f!, y, ::AutoForwardEnzyme, x) = NoPushforwardExtras()
+DI.prepare_pushforward(f!, y, ::AutoForwardEnzyme, x, dx) = NoPushforwardExtras()
 
 function DI.value_and_pushforward(
     f!, y, backend::AutoForwardEnzyme, x, dx, ::NoPushforwardExtras
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceEnzymeExt/reverse_onearg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceEnzymeExt/reverse_onearg.jl
@@ -1,6 +1,6 @@
 ## Pullback
 
-DI.prepare_pullback(f, ::AutoReverseEnzyme, x) = NoPullbackExtras()
+DI.prepare_pullback(f, ::AutoReverseEnzyme, x, dy) = NoPullbackExtras()
 
 ### Out-of-place
 
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceEnzymeExt/reverse_twoarg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceEnzymeExt/reverse_twoarg.jl
@@ -1,6 +1,6 @@
 ## Pullback
 
-DI.prepare_pullback(f!, y, ::AutoReverseEnzyme, x) = NoPullbackExtras()
+DI.prepare_pullback(f!, y, ::AutoReverseEnzyme, x, dy) = NoPullbackExtras()
 
 function DI.value_and_pullback(
     f!, y, ::AutoReverseEnzyme, x::Number, dy, ::NoPullbackExtras
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceFastDifferentiationExt/onearg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceFastDifferentiationExt/onearg.jl
@@ -6,7 +6,7 @@ struct FastDifferentiationOneArgPushforwardExtras{Y,E1,E2} <: PushforwardExtras
     jvp_exe!::E2
 end
 
-function DI.prepare_pushforward(f, ::AnyAutoFastDifferentiation, x)
+function DI.prepare_pushforward(f, ::AnyAutoFastDifferentiation, x, dx)
     y_prototype = f(x)
     x_var = if x isa Number
         only(make_variables(:x))
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceFastDifferentiationExt/twoarg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceFastDifferentiationExt/twoarg.jl
@@ -5,7 +5,7 @@ struct FastDifferentiationTwoArgPushforwardExtras{E1,E2} <: PushforwardExtras
     jvp_exe!::E2
 end
 
-function DI.prepare_pushforward(f!, y, ::AnyAutoFastDifferentiation, x)
+function DI.prepare_pushforward(f!, y, ::AnyAutoFastDifferentiation, x, dx)
     x_var = if x isa Number
         only(make_variables(:x))
     else
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceFiniteDiffExt/onearg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceFiniteDiffExt/onearg.jl
@@ -1,6 +1,6 @@
 ## Pushforward
 
-DI.prepare_pushforward(f, ::AutoFiniteDiff, x) = NoPushforwardExtras()
+DI.prepare_pushforward(f, ::AutoFiniteDiff, x, dx) = NoPushforwardExtras()
 
 function DI.pushforward(f, backend::AutoFiniteDiff, x, dx, ::NoPushforwardExtras)
     step(t::Number) = f(x .+ t .* dx)
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceFiniteDiffExt/twoarg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceFiniteDiffExt/twoarg.jl
@@ -1,6 +1,6 @@
 ## Pushforward
 
-DI.prepare_pushforward(f!, y, ::AutoFiniteDiff, x) = NoPushforwardExtras()
+DI.prepare_pushforward(f!, y, ::AutoFiniteDiff, x, dx) = NoPushforwardExtras()
 
 function DI.value_and_pushforward(
     f!, y, backend::AutoFiniteDiff, x, dx, ::NoPushforwardExtras
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceFiniteDifferencesExt/DifferentiationInterfaceFiniteDifferencesExt.jl b/DifferentiationInterface/ext/DifferentiationInterfaceFiniteDifferencesExt/DifferentiationInterfaceFiniteDifferencesExt.jl
@@ -17,7 +17,7 @@ end
 
 ## Pushforward
 
-DI.prepare_pushforward(f, ::AutoFiniteDifferences, x) = NoPushforwardExtras()
+DI.prepare_pushforward(f, ::AutoFiniteDifferences, x, dx) = NoPushforwardExtras()
 
 function DI.pushforward(f, backend::AutoFiniteDifferences, x, dx, ::NoPushforwardExtras)
     return jvp(backend.fdm, f, (x, dx))
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/onearg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/onearg.jl
@@ -1,6 +1,6 @@
 ## Pushforward
 
-DI.prepare_pushforward(f, ::AutoForwardDiff, x) = NoPushforwardExtras()
+DI.prepare_pushforward(f, ::AutoForwardDiff, x, dx) = NoPushforwardExtras()
 
 function DI.value_and_pushforward(f, ::AutoForwardDiff, x, dx, ::NoPushforwardExtras)
     T = tag_type(f, x)
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/twoarg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceForwardDiffExt/twoarg.jl
@@ -1,4 +1,4 @@
-DI.prepare_pushforward(f!, y, ::AutoForwardDiff, x) = NoPushforwardExtras()
+DI.prepare_pushforward(f!, y, ::AutoForwardDiff, x, dx) = NoPushforwardExtras()
 
 function DI.value_and_pushforward(f!, y, ::AutoForwardDiff, x, dx, ::NoPushforwardExtras)
     T = tag_type(f!, x)
diff --git a/DifferentiationInterface/ext/DifferentiationInterfacePolyesterForwardDiffExt/onearg.jl b/DifferentiationInterface/ext/DifferentiationInterfacePolyesterForwardDiffExt/onearg.jl
@@ -1,8 +1,8 @@
 
 ## Pushforward
 
-function DI.prepare_pushforward(f, backend::AutoPolyesterForwardDiff, x)
-    return DI.prepare_pushforward(f, single_threaded(backend), x)
+function DI.prepare_pushforward(f, backend::AutoPolyesterForwardDiff, x, dx)
+    return DI.prepare_pushforward(f, single_threaded(backend), x, dx)
 end
 
 function DI.value_and_pushforward(
diff --git a/DifferentiationInterface/ext/DifferentiationInterfacePolyesterForwardDiffExt/twoarg.jl b/DifferentiationInterface/ext/DifferentiationInterfacePolyesterForwardDiffExt/twoarg.jl
@@ -1,7 +1,7 @@
 ## Pushforward
 
-function DI.prepare_pushforward(f!, y, backend::AutoPolyesterForwardDiff, x)
-    return DI.prepare_pushforward(f!, y, single_threaded(backend), x)
+function DI.prepare_pushforward(f!, y, backend::AutoPolyesterForwardDiff, x, dx)
+    return DI.prepare_pushforward(f!, y, single_threaded(backend), x, dx)
 end
 
 function DI.value_and_pushforward(
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceReverseDiffExt/onearg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceReverseDiffExt/onearg.jl
@@ -1,6 +1,6 @@
 ## Pullback
 
-DI.prepare_pullback(f, ::AutoReverseDiff, x) = NoPullbackExtras()
+DI.prepare_pullback(f, ::AutoReverseDiff, x, dy) = NoPullbackExtras()
 
 function DI.value_and_pullback(
     f, ::AutoReverseDiff, x::AbstractArray, dy, ::NoPullbackExtras
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceReverseDiffExt/twoarg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceReverseDiffExt/twoarg.jl
@@ -1,6 +1,6 @@
 ## Pullback
 
-DI.prepare_pullback(f!, y, ::AutoReverseDiff, x) = NoPullbackExtras()
+DI.prepare_pullback(f!, y, ::AutoReverseDiff, x, dy) = NoPullbackExtras()
 
 ### Array in
 
@@ -60,7 +60,7 @@ function DI.value_and_pullback(
     x_array = [x]
     dx_array = similar(x_array)
     f!_array(_y::AbstractArray, _x_array) = f!(_y, only(_x_array))
-    new_extras = DI.prepare_pullback(f!_array, y, backend, x_array)
+    new_extras = DI.prepare_pullback(f!_array, y, backend, x_array, dy)
     y, dx_array = DI.value_and_pullback(f!_array, y, backend, x_array, dy, new_extras)
     return y, only(dx_array)
 end
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceTapirExt/onearg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceTapirExt/onearg.jl
@@ -3,7 +3,7 @@ struct TapirOneArgPullbackExtras{Y,R} <: PullbackExtras
     rrule::R
 end
 
-function DI.prepare_pullback(f, ::AutoTapir, x)
+function DI.prepare_pullback(f, ::AutoTapir, x, dy)
     y = f(x)
     rrule = build_rrule(f, x)
     return TapirOneArgPullbackExtras(y, rrule)
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceTapirExt/twoarg.jl b/DifferentiationInterface/ext/DifferentiationInterfaceTapirExt/twoarg.jl
@@ -2,7 +2,7 @@ struct TapirTwoArgPullbackExtras{R} <: PullbackExtras
     rrule::R
 end
 
-function DI.prepare_pullback(f!, y, ::AutoTapir, x)
+function DI.prepare_pullback(f!, y, ::AutoTapir, x, dy)
     return TapirTwoArgPullbackExtras(build_rrule(f!, y, x))
 end
 
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceTrackerExt/DifferentiationInterfaceTrackerExt.jl b/DifferentiationInterface/ext/DifferentiationInterfaceTrackerExt/DifferentiationInterfaceTrackerExt.jl
@@ -10,7 +10,7 @@ DI.mutation_support(::AutoTracker) = DI.MutationNotSupported()
 
 ## Pullback
 
-DI.prepare_pullback(f, ::AutoTracker, x) = NoPullbackExtras()
+DI.prepare_pullback(f, ::AutoTracker, x, dy) = NoPullbackExtras()
 
 function DI.value_and_pullback_split(f, ::AutoTracker, x, ::NoPullbackExtras)
     y, back = forward(f, x)
diff --git a/DifferentiationInterface/ext/DifferentiationInterfaceZygoteExt/DifferentiationInterfaceZygoteExt.jl b/DifferentiationInterface/ext/DifferentiationInterfaceZygoteExt/DifferentiationInterfaceZygoteExt.jl
@@ -13,7 +13,7 @@ DI.mutation_support(::Union{AutoZygote,AutoSparseZygote}) = DI.MutationNotSuppor
 
 ## Pullback
 
-DI.prepare_pullback(f, ::AutoZygote, x) = NoPullbackExtras()
+DI.prepare_pullback(f, ::AutoZygote, x, dy) = NoPullbackExtras()
 
 function DI.value_and_pullback_split(f, ::AutoZygote, x, ::NoPullbackExtras)
     y, back = pullback(f, x)
diff --git a/DifferentiationInterface/src/derivative.jl b/DifferentiationInterface/src/derivative.jl
@@ -50,11 +50,14 @@ struct PushforwardDerivativeExtras{E<:PushforwardExtras} <: DerivativeExtras
 end
 
 function prepare_derivative(f, backend::AbstractADType, x)
-    return PushforwardDerivativeExtras(prepare_pushforward(f, backend, x))
+    dx = one(x)
+    return PushforwardDerivativeExtras(prepare_pushforward(f, backend, x, dx))
 end
 
 function prepare_derivative(f!, y, backend::AbstractADType, x)
-    return PushforwardDerivativeExtras(prepare_pushforward(f!, y, backend, x))
+    dx = one(x)
+    pushforward_extras = prepare_pushforward(f!, y, backend, x, dx)
+    return PushforwardDerivativeExtras(pushforward_extras)
 end
 
 ## One argument
diff --git a/DifferentiationInterface/src/gradient.jl b/DifferentiationInterface/src/gradient.jl
@@ -43,7 +43,10 @@ struct PullbackGradientExtras{E<:PullbackExtras} <: GradientExtras
 end
 
 function prepare_gradient(f, backend::AbstractADType, x)
-    return PullbackGradientExtras(prepare_pullback(f, backend, x))
+    y = f(x)
+    dy = one(y)
+    pullback_extras = prepare_pullback(f, backend, x, dy)
+    return PullbackGradientExtras(pullback_extras)
 end
 
 ## One argument
diff --git a/DifferentiationInterface/src/hessian.jl b/DifferentiationInterface/src/hessian.jl
@@ -33,9 +33,9 @@ struct HVPHessianExtras{E<:HVPExtras} <: HessianExtras
 end
 
 function prepare_hessian(f, backend::AbstractADType, x)
-    return HVPHessianExtras(
-        prepare_hvp(f, backend, x, basis(backend, x, first(CartesianIndices(x))))
-    )
+    v = basis(backend, x, first(CartesianIndices(x)))
+    hvp_extras = prepare_hvp(f, backend, x, v)
+    return HVPHessianExtras(hvp_extras)
 end
 
 ## One argument
diff --git a/DifferentiationInterface/src/hvp.jl b/DifferentiationInterface/src/hvp.jl
@@ -4,9 +4,6 @@
     prepare_hvp(f, backend, x, v) -> extras
 
 Create an `extras` object subtyping [`HVPExtras`](@ref) that can be given to Hessian-vector product operators.
-
-!!! warning
-    Unlike the others, this preparation operator takes an additional argument `v`.
 """
 function prepare_hvp end
 
@@ -71,7 +68,7 @@ function prepare_hvp_aux(f, backend::SecondOrder, x, v, ::ForwardOverForward)
     # pushforward of many pushforwards in theory, but pushforward of gradient in practice
     inner_gradient_closure(z) = gradient(f, inner(backend), z)
     outer_pushforward_extras = prepare_pushforward(
-        inner_gradient_closure, outer(backend), x
+        inner_gradient_closure, outer(backend), x, v
     )
     return ForwardOverForwardHVPExtras(inner_gradient_closure, outer_pushforward_extras)
 end
@@ -80,7 +77,7 @@ function prepare_hvp_aux(f, backend::SecondOrder, x, v, ::ForwardOverReverse)
     # pushforward of gradient
     inner_gradient_closure(z) = gradient(f, inner(backend), z)
     outer_pushforward_extras = prepare_pushforward(
-        inner_gradient_closure, outer(backend), x
+        inner_gradient_closure, outer(backend), x, v
     )
     return ForwardOverReverseHVPExtras(inner_gradient_closure, outer_pushforward_extras)
 end
@@ -100,7 +97,7 @@ end
 function prepare_hvp_aux(f, backend::SecondOrder, x, v, ::ReverseOverReverse)
     # pullback of the gradient
     inner_gradient_closure(z) = gradient(f, inner(backend), z)
-    outer_pullback_extras = prepare_pullback(inner_gradient_closure, outer(backend), x)
+    outer_pullback_extras = prepare_pullback(inner_gradient_closure, outer(backend), x, v)
     return ReverseOverReverseHVPExtras(inner_gradient_closure, outer_pullback_extras)
 end
 
@@ -119,28 +116,28 @@ function hvp(f, backend::SecondOrder, x, v, extras::HVPExtras=prepare_hvp(f, bac
 end
 
 function hvp_aux(f, backend, x, v, extras::ForwardOverForwardHVPExtras)
+    (; inner_gradient_closure, outer_pushforward_extras) = extras
     return pushforward(
-        extras.inner_gradient_closure, outer(backend), x, v, extras.outer_pushforward_extras
+        inner_gradient_closure, outer(backend), x, v, outer_pushforward_extras
     )
 end
 
 function hvp_aux(f, backend, x, v, extras::ForwardOverReverseHVPExtras)
+    (; inner_gradient_closure, outer_pushforward_extras) = extras
     return pushforward(
-        extras.inner_gradient_closure, outer(backend), x, v, extras.outer_pushforward_extras
+        inner_gradient_closure, outer(backend), x, v, outer_pushforward_extras
     )
 end
 
 function hvp_aux(f, backend, x, v, extras::ReverseOverForwardHVPExtras)
-    inner_pushforward_closure = extras.inner_pushforward_closure_generator(v)
-    return gradient(
-        inner_pushforward_closure, outer(backend), x, extras.outer_gradient_extras
-    )
+    (; inner_pushforward_closure_generator, outer_gradient_extras) = extras
+    inner_pushforward_closure = inner_pushforward_closure_generator(v)
+    return gradient(inner_pushforward_closure, outer(backend), x, outer_gradient_extras)
 end
 
 function hvp_aux(f, backend, x, v, extras::ReverseOverReverseHVPExtras)
-    return pullback(
-        extras.inner_gradient_closure, outer(backend), x, v, extras.outer_pullback_extras
-    )
+    (; inner_gradient_closure, outer_pullback_extras) = extras
+    return pullback(inner_gradient_closure, outer(backend), x, v, outer_pullback_extras)
 end
 
 function hvp!(
@@ -158,36 +155,26 @@ function hvp!(
 end
 
 function hvp_aux!(f, p, backend, x, v, extras::ForwardOverForwardHVPExtras)
+    (; inner_gradient_closure, outer_pushforward_extras) = extras
     return pushforward!(
-        extras.inner_gradient_closure,
-        p,
-        outer(backend),
-        x,
-        v,
-        extras.outer_pushforward_extras,
+        inner_gradient_closure, p, outer(backend), x, v, outer_pushforward_extras
     )
 end
 
 function hvp_aux!(f, p, backend, x, v, extras::ForwardOverReverseHVPExtras)
+    (; inner_gradient_closure, outer_pushforward_extras) = extras
     return pushforward!(
-        extras.inner_gradient_closure,
-        p,
-        outer(backend),
-        x,
-        v,
-        extras.outer_pushforward_extras,
+        inner_gradient_closure, p, outer(backend), x, v, outer_pushforward_extras
     )
 end
 
 function hvp_aux!(f, p, backend, x, v, extras::ReverseOverForwardHVPExtras)
-    inner_pushforward_closure = extras.inner_pushforward_closure_generator(v)
-    return gradient!(
-        inner_pushforward_closure, p, outer(backend), x, extras.outer_gradient_extras
-    )
+    (; inner_pushforward_closure_generator, outer_gradient_extras) = extras
+    inner_pushforward_closure = inner_pushforward_closure_generator(v)
+    return gradient!(inner_pushforward_closure, p, outer(backend), x, outer_gradient_extras)
 end
 
 function hvp_aux!(f, p, backend, x, v, extras::ReverseOverReverseHVPExtras)
-    return pullback!(
-        extras.inner_gradient_closure, p, outer(backend), x, v, extras.outer_pullback_extras
-    )
+    (; inner_gradient_closure, outer_pullback_extras) = extras
+    return pullback!(inner_gradient_closure, p, outer(backend), x, v, outer_pullback_extras)
 end
diff --git a/DifferentiationInterface/src/jacobian.jl b/DifferentiationInterface/src/jacobian.jl
@@ -62,19 +62,28 @@ function prepare_jacobian(f!, y, backend::AbstractADType, x)
 end
 
 function prepare_jacobian_aux(f, backend, x, ::PushforwardFast)
-    return PushforwardJacobianExtras(prepare_pushforward(f, backend, x))
+    dx = basis(backend, x, first(CartesianIndices(x)))
+    pushforward_extras = prepare_pushforward(f, backend, x, dx)
+    return PushforwardJacobianExtras(pushforward_extras)
 end
 
 function prepare_jacobian_aux(f!, y, backend, x, ::PushforwardFast)
-    return PushforwardJacobianExtras(prepare_pushforward(f!, y, backend, x))
+    dx = basis(backend, x, first(CartesianIndices(x)))
+    pushforward_extras = prepare_pushforward(f!, y, backend, x, dx)
+    return PushforwardJacobianExtras(pushforward_extras)
 end
 
 function prepare_jacobian_aux(f, backend, x, ::PushforwardSlow)
-    return PullbackJacobianExtras(prepare_pullback(f, backend, x))
+    y = f(x)
+    dy = basis(backend, y, first(CartesianIndices(y)))
+    pullback_extras = prepare_pullback(f, backend, x, dy)
+    return PullbackJacobianExtras(pullback_extras)
 end
 
 function prepare_jacobian_aux(f!, y, backend, x, ::PushforwardSlow)
-    return PullbackJacobianExtras(prepare_pullback(f!, y, backend, x))
+    dy = basis(backend, y, first(CartesianIndices(y)))
+    pullback_extras = prepare_pullback(f!, y, backend, x, dy)
+    return PullbackJacobianExtras(pullback_extras)
 end
 
 ## One argument
diff --git a/DifferentiationInterface/src/pullback.jl b/DifferentiationInterface/src/pullback.jl
diff --git a/DifferentiationInterface/src/pushforward.jl b/DifferentiationInterface/src/pushforward.jl
diff --git a/DifferentiationInterface/src/second_derivative.jl b/DifferentiationInterface/src/second_derivative.jl
diff --git a/DifferentiationInterfaceTest/src/tests/benchmark.jl b/DifferentiationInterfaceTest/src/tests/benchmark.jl
diff --git a/DifferentiationInterfaceTest/src/tests/correctness.jl b/DifferentiationInterfaceTest/src/tests/correctness.jl
diff --git a/DifferentiationInterfaceTest/src/tests/type_stability.jl b/DifferentiationInterfaceTest/src/tests/type_stability.jl
diff --git a/DifferentiationInterfaceTest/src/utils/zero_backends.jl b/DifferentiationInterfaceTest/src/utils/zero_backends.jl
diff --git a/DifferentiationInterfaceTest/test/zero_backends.jl b/DifferentiationInterfaceTest/test/zero_backends.jl
