Make SimplexBijector actually bijective

ext/BijectorsDistributionsADExt.jl

@@ -78,27 +78,19 @@ Bijectors.isdirichlet(::VectorOfMultivariate{Continuous,<:Dirichlet}) = true
 Bijectors.isdirichlet(::VectorOfMultivariate{Continuous,<:TuringDirichlet}) = true
 Bijectors.isdirichlet(::TuringDirichlet) = true
 
-function Bijectors.link(
-    d::TuringDirichlet, x::AbstractVecOrMat{<:Real}, ::Val{proj}=Val(true)
-) where {proj}
-    return Bijectors.SimplexBijector{proj}()(x)
+function Bijectors.link(d::TuringDirichlet, x::AbstractVecOrMat{<:Real})
+    return Bijectors.SimplexBijector()(x)
 end
 
-function Bijectors.link_jacobian(
-    d::TuringDirichlet, x::AbstractVector{<:Real}, ::Val{proj}=Val(true)
-) where {proj}
-    return jacobian(Bijectors.SimplexBijector{proj}(), x)
+function Bijectors.link_jacobian(d::TuringDirichlet, x::AbstractVector{<:Real})
+    return jacobian(Bijectors.SimplexBijector(), x)
 end
 
-function Bijectors.invlink(
-    d::TuringDirichlet, y::AbstractVecOrMat{<:Real}, ::Val{proj}=Val(true)
-) where {proj}
-    return inverse(Bijectors.SimplexBijector{proj}())(y)
+function Bijectors.invlink(d::TuringDirichlet, y::AbstractVecOrMat{<:Real})
+    return inverse(Bijectors.SimplexBijector())(y)
 end
-function Bijectors.invlink_jacobian(
-    d::TuringDirichlet, y::AbstractVector{<:Real}, ::Val{proj}=Val(true)
-) where {proj}
-    return jacobian(inverse(Bijectors.SimplexBijector{proj}()), y)
+function Bijectors.invlink_jacobian(d::TuringDirichlet, y::AbstractVector{<:Real})
+    return jacobian(inverse(Bijectors.SimplexBijector()), y)
 end
 
 Bijectors.ispd(::TuringWishart) = true

src/Bijectors.jl

@@ -206,25 +206,12 @@ isdirichlet(::Distribution) = false
 # ∑xᵢ = 1 #
 ###########
 
-function link(d::Dirichlet, x::AbstractVecOrMat{<:Real}, ::Val{proj}=Val(true)) where {proj}
-    return SimplexBijector{proj}()(x)
-end
-
-function link_jacobian(
-    d::Dirichlet, x::AbstractVector{<:Real}, ::Val{proj}=Val(true)
-) where {proj}
-    return jacobian(SimplexBijector{proj}(), x)
-end
+link(d::Dirichlet, x::AbstractVecOrMat{<:Real}) = SimplexBijector()(x)
+link_jacobian(d::Dirichlet, x::AbstractVector{<:Real}) = jacobian(SimplexBijector(), x)
 
-function invlink(
-    d::Dirichlet, y::AbstractVecOrMat{<:Real}, ::Val{proj}=Val(true)
-) where {proj}
-    return inverse(SimplexBijector{proj}())(y)
-end
-function invlink_jacobian(
-    d::Dirichlet, y::AbstractVector{<:Real}, ::Val{proj}=Val(true)
-) where {proj}
-    return jacobian(inverse(SimplexBijector{proj}()), y)
+invlink(d::Dirichlet, y::AbstractVecOrMat{<:Real}) = inverse(SimplexBijector())(y)
+function invlink_jacobian(d::Dirichlet, y::AbstractVector{<:Real})
+    return jacobian(inverse(SimplexBijector()), y)
 end
 
 ## Matrix

src/bijectors/simplex.jl

@@ -1,20 +1,31 @@
 ####################
 # Simplex bijector #
 ####################
-struct SimplexBijector{T} <: Bijector end
-SimplexBijector() = SimplexBijector{true}()
+struct SimplexBijector <: Bijector end
+
+output_size(::SimplexBijector, sz::Tuple{Int}) = (first(sz) - 1,)
+output_size(::Inverse{SimplexBijector}, sz::Tuple{Int}) = (first(sz) + 1,)
+
+output_size(::SimplexBijector, sz::Tuple{Int,Int}) = (first(sz) - 1, last(sz))
+function output_size(::Inverse{SimplexBijector}, sz::Tuple{Int,Int})
+    return (first(sz) + 1, last(sz))
+end
 
 with_logabsdet_jacobian(b::SimplexBijector, x) = transform(b, x), logabsdetjac(b, x)
 
 transform(b::SimplexBijector, x) = _simplex_bijector(x, b)
 transform!(b::SimplexBijector, y, x) = _simplex_bijector!(y, x, b)
 
 function _simplex_bijector(x::AbstractArray, b::SimplexBijector)
-    return _simplex_bijector!(similar(x), x, b)
+    sz = size(x)
+    K = size(x, 1)
+    y = similar(x, Base.setindex(sz, K - 1, 1))
+    _simplex_bijector!(y, x, b)
+    return y
 end
 
 # Vector implementation.
-function _simplex_bijector!(y, x::AbstractVector, ::SimplexBijector{proj}) where {proj}
+function _simplex_bijector!(y, x::AbstractVector, ::SimplexBijector)
     K = length(x)
     @assert K > 1 "x needs to be of length greater than 1"
     T = eltype(x)
@@ -29,18 +40,11 @@ function _simplex_bijector!(y, x::AbstractVector, ::SimplexBijector{proj}) where
         z = (x[k] + ϵ) * (one(T) - 2ϵ) / ((one(T) + ϵ) - sum_tmp)
         y[k] = LogExpFunctions.logit(z) + log(T(K - k))
     end
-    @inbounds sum_tmp += x[K - 1]
-    @inbounds if proj
-        y[K] = zero(T)
-    else
-        y[K] = one(T) - sum_tmp - x[K]
-    end
-
     return y
 end
 
 # Matrix implementation.
-function _simplex_bijector!(Y, X::AbstractMatrix, ::SimplexBijector{proj}) where {proj}
+function _simplex_bijector!(Y, X::AbstractMatrix, ::SimplexBijector)
     K, N = size(X, 1), size(X, 2)
     @assert K > 1 "x needs to be of length greater than 1"
     T = eltype(X)
@@ -54,12 +58,6 @@ function _simplex_bijector!(Y, X::AbstractMatrix, ::SimplexBijector{proj}) where
             z = (X[k, n] + ϵ) * (one(T) - 2ϵ) / ((one(T) + ϵ) - sum_tmp)
             Y[k, n] = LogExpFunctions.logit(z) + log(T(K - k))
         end
-        sum_tmp += X[K - 1, n]
-        if proj
-            Y[K, n] = zero(T)
-        else
-            Y[K, n] = one(T) - sum_tmp - X[K, n]
-        end
     end
 
     return Y
@@ -75,10 +73,16 @@ function transform!(
     return _simplex_inv_bijector!(x, y, ib.orig)
 end
 
-_simplex_inv_bijector(y, b) = _simplex_inv_bijector!(similar(y), y, b)
+function _simplex_inv_bijector(y, b)
+    sz = size(y)
+    K = sz[1] + 1
+    x = similar(y, Base.setindex(sz, K, 1))
+    _simplex_inv_bijector!(x, y, b)
+    return x
+end
 
-function _simplex_inv_bijector!(x, y::AbstractVector, b::SimplexBijector{proj}) where {proj}
-    K = length(y)
+function _simplex_inv_bijector!(x, y::AbstractVector, b::SimplexBijector)
+    K = length(y) + 1
     @assert K > 1 "x needs to be of length greater than 1"
     T = eltype(y)
     ϵ = _eps(T)
@@ -91,17 +95,12 @@ function _simplex_inv_bijector!(x, y::AbstractVector, b::SimplexBijector{proj})
         x[k] = _clamp(((one(T) + ϵ) - sum_tmp) / (one(T) - 2ϵ) * z - ϵ, 0, 1)
     end
     @inbounds sum_tmp += x[K - 1]
-    @inbounds if proj
-        x[K] = _clamp(one(T) - sum_tmp, 0, 1)
-    else
-        x[K] = _clamp(one(T) - sum_tmp - y[K], 0, 1)
-    end
-
+    x[K] = _clamp(one(T) - sum_tmp, 0, 1)
     return x
 end
 
-function _simplex_inv_bijector!(X, Y::AbstractMatrix, b::SimplexBijector{proj}) where {proj}
-    K, N = size(Y, 1), size(Y, 2)
+function _simplex_inv_bijector!(X, Y::AbstractMatrix, b::SimplexBijector)
+    K, N = size(Y, 1) + 1, size(Y, 2)
     @assert K > 1 "x needs to be of length greater than 1"
     T = eltype(Y)
     ϵ = _eps(T)
@@ -114,11 +113,7 @@ function _simplex_inv_bijector!(X, Y::AbstractMatrix, b::SimplexBijector{proj})
             X[k, n] = _clamp(((one(T) + ϵ) - sum_tmp) / (one(T) - 2ϵ) * z - ϵ, 0, 1)
         end
         sum_tmp += X[K - 1, n]
-        if proj
-            X[K, n] = _clamp(one(T) - sum_tmp, 0, 1)
-        else
-            X[K, n] = _clamp(one(T) - sum_tmp - Y[K, n], 0, 1)
-        end
+        X[K, n] = _clamp(one(T) - sum_tmp, 0, 1)
     end
 
     return X
@@ -213,13 +208,10 @@ function simplex_logabsdetjac_gradient(x::AbstractMatrix)
     return g
 end
 
-function simplex_link_jacobian(
-    x::AbstractVector{T}, ::Val{proj}=Val(true)
-) where {T<:Real,proj}
+function simplex_link_jacobian(x::AbstractVector{T}) where {T<:Real}
     K = length(x)
     @assert K > 1 "x needs to be of length greater than 1"
-    dydxt = similar(x, length(x), length(x))
-    @inbounds dydxt .= 0
+    dydxt = fill!(similar(x, K, K - 1), 0)
     ϵ = _eps(T)
     sum_tmp = zero(T)
 
@@ -237,16 +229,10 @@ function simplex_link_jacobian(
                 ((one(T) + ϵ) - sum_tmp)^2
         end
     end
-    @inbounds sum_tmp += x[K - 1]
-    @inbounds if !proj
-        @simd for i in 1:K
-            dydxt[i, K] = -1
-        end
-    end
-    return UpperTriangular(dydxt)'
+    return dydxt'
 end
-function jacobian(b::SimplexBijector{proj}, x::AbstractVector{T}) where {proj,T}
-    return simplex_link_jacobian(x, Val(proj))
+function jacobian(b::SimplexBijector, x::AbstractVector{T}) where {T}
+    return simplex_link_jacobian(x)
 end
 
 #=
@@ -315,13 +301,10 @@ function add_simplex_link_adjoint!(
 end
 =#
 
-function simplex_invlink_jacobian(
-    y::AbstractVector{T}, ::Val{proj}=Val(true)
-) where {T<:Real,proj}
-    K = length(y)
+function simplex_invlink_jacobian(y::AbstractVector{T}) where {T<:Real}
+    K = length(y) + 1
     @assert K > 1 "x needs to be of length greater than 1"
-    dxdy = similar(y, length(y), length(y))
-    @inbounds dxdy .= 0
+    dxdy = fill!(similar(y, K, K - 1), 0)
 
     ϵ = _eps(T)
     @inbounds z = LogExpFunctions.logistic(y[1] - log(T(K - 1)))
@@ -346,28 +329,20 @@ function simplex_invlink_jacobian(
         end
     end
     @inbounds sum_tmp += clamped_x
-    @inbounds if proj
-        unclamped_x = one(T) - sum_tmp
-        clamped_x = _clamp(unclamped_x, 0, 1)
-    else
-        unclamped_x = one(T) - sum_tmp - y[K]
-        clamped_x = _clamp(unclamped_x, 0, 1)
-        if unclamped_x == clamped_x
-            dxdy[K, K] = -1
-        end
-    end
+    unclamped_x = one(T) - sum_tmp
+    clamped_x = _clamp(unclamped_x, 0, 1)
     @inbounds if unclamped_x == clamped_x
         for i in 1:(K - 1)
             @simd for j in i:(K - 1)
                 dxdy[K, i] += -dxdy[j, i]
             end
         end
     end
-    return LowerTriangular(dxdy)
+    return dxdy
 end
 # jacobian
-function jacobian(ib::Inverse{<:SimplexBijector{proj}}, y::AbstractVector{T}) where {proj,T}
-    return simplex_invlink_jacobian(y, Val(proj))
+function jacobian(ib::Inverse{<:SimplexBijector}, y::AbstractVector{T}) where {T}
+    return simplex_invlink_jacobian(y)
 end
 
 #=

src/bijectors/stacked.jl

@@ -85,9 +85,6 @@ end
     end
 end
 
-# Avoid mixing tuples and arrays.
-Stacked(bs::Tuple, ranges::AbstractArray) = Stacked(collect(bs), ranges)
-
 Functors.@functor Stacked (bs,)
 
 function Base.show(io::IO, b::Stacked)

test/interface.jl

@@ -156,7 +156,7 @@ end
             # verify against AD
             # similar to what we do in test/transform.jl for Dirichlet
             if dist isa Dirichlet
-                b = Bijectors.SimplexBijector{false}()
+                b = Bijectors.SimplexBijector()
                 # HACK(torfjelde): Calling `rand(dist)` will sometimes lead to `[0.999..., 0.0]`
                 # which in turn will lead to differences between `ForwardDiff.jacobian`
                 # and `logabsdetjac` due to how we handle the boundary values in `SimplexBijector`.
@@ -168,8 +168,9 @@ end
                 end
                 y = b(x)
                 @test b(param(x)) isa TrackedArray
-                @test log(abs(det(ForwardDiff.jacobian(b, x)))) ≈ logabsdetjac(b, x)
-                @test log(abs(det(ForwardDiff.jacobian(inverse(b), y)))) ≈
+                @test logabsdet(ForwardDiff.jacobian(b, x)[:, 1:(end - 1)])[1] ≈
+                    logabsdetjac(b, x)
+                @test logabsdet(ForwardDiff.jacobian(inverse(b), y)[1:(end - 1), :])[1] ≈
                     logabsdetjac(inverse(b), y)
             else
                 b = bijector(dist)
@@ -420,35 +421,37 @@ end
     b = SimplexBijector()
     ib = inverse(b)
 
-    x = ib(randn(10))
+    d_x = 10
+    x = ib(randn(d_x - 1))
     y = b(x)
 
     @test Bijectors.jacobian(b, x) ≈ ForwardDiff.jacobian(b, x)
     @test Bijectors.jacobian(ib, y) ≈ ForwardDiff.jacobian(ib, y)
 
     # Just some additional computation so we also ensure the pullbacks are the same
-    weights = randn(10)
+    weights_x = randn(d_x)
+    weights_y = randn(d_x - 1)
 
     # Tracker.jl
     x_tracked = Tracker.param(x)
-    z = sum(weights .* b(x_tracked))
+    z = sum(weights_y .* b(x_tracked))
     Tracker.back!(z)
     Δ_tracker = Tracker.grad(x_tracked)
 
     # ForwardDiff.jl
-    Δ_forwarddiff = ForwardDiff.gradient(z -> sum(weights .* b(z)), x)
+    Δ_forwarddiff = ForwardDiff.gradient(z -> sum(weights_y .* b(z)), x)
 
     # Compare
     @test Δ_forwarddiff ≈ Δ_tracker
 
     # Tracker.jl
     y_tracked = Tracker.param(y)
-    z = sum(weights .* ib(y_tracked))
+    z = sum(weights_x .* ib(y_tracked))
     Tracker.back!(z)
     Δ_tracker = Tracker.grad(y_tracked)
 
     # ForwardDiff.jl
-    Δ_forwarddiff = ForwardDiff.gradient(z -> sum(weights .* ib(z)), y)
+    Δ_forwarddiff = ForwardDiff.gradient(z -> sum(weights_x .* ib(z)), y)
 
     @test Δ_forwarddiff ≈ Δ_tracker
 end